comparing 9436c5434037c9dde5e579b679df9e95e20bf3ae and master on nel.pet/core

-21

appview/pages/templates/index.html

···

       1
       -
       <html>

     

       2
       -
           {{ template "layouts/head" . }}

     

       3
       -
       

     

       4
       -
           <header>

     

       5
       -
               <h1>{{ .meta.Title }}</h1>

     

       6
       -
               <h2>{{ .meta.Description }}</h2>

     

       7
       -
           </header>

     

       8
       -
           <body>

     

       9
       -
               <main>

     

       10
       -
                   <div class="index">

     

       11
       -
                       {{ range .info }}

     

       12
       -
                       <div class="index-name">

     

       13
       -
                           <a href="/{{ .Name }}">{{ .DisplayName }}</a>

     

       14
       -
                       </div>

     

       15
       -
                       <div class="desc">{{ .Desc }}</div>

     

       16
       -
                       <div>{{ .Idle }}</div>

     

       17
       -
                       {{ end }}

     

       18
       -
                   </div>

     

       19
       -
               </main>

     

       20
       -
           </body>

     

       21
       -
       </html>

appview/pages/htmx.go

···

       15
        
       	w.Write([]byte(html))

     

       16
        
       }

     

       17
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       // HxRedirect is a full page reload with a new location.

     

       19
        
       func (s *Pages) HxRedirect(w http.ResponseWriter, location string) {

     

       20
        
       	w.Header().Set("HX-Redirect", location)

···

       15
        
       	w.Write([]byte(html))

     

       16
        
       }

     

       17
        
       

     

       18
       +
       // HxRefresh is a client-side full refresh of the page.

     

       19
       +
       func (s *Pages) HxRefresh(w http.ResponseWriter) {

     

       20
       +
       	w.Header().Set("HX-Refresh", "true")

     

       21
       +
       	w.WriteHeader(http.StatusOK)

     

       22
       +
       }

     

       23
       +
       

     

       24
        
       // HxRedirect is a full page reload with a new location.

     

       25
        
       func (s *Pages) HxRedirect(w http.ResponseWriter, location string) {

     

       26
        
       	w.Header().Set("HX-Redirect", location)

+2 -1

camo/src/mimetypes.json

···

       41
        
         "image/x-rgb",

     

       42
        
         "image/x-xbitmap",

     

       43
        
         "image/x-xpixmap",

     

       44
       -
         "image/x-xwindowdump"

     

       0
        
       
     

       45
        
       ]

···

       41
        
         "image/x-rgb",

     

       42
        
         "image/x-xbitmap",

     

       43
        
         "image/x-xpixmap",

     

       44
       +
         "image/x-xwindowdump",

     

       45
       +
         "video/mp4"

     

       46
        
       ]

+2 -1

license

···

       1
        
       MIT License

     

       2
        
       

     

       3
       -
       Copyright (c) 2025 Anirudh Oppiliappan, Akshay Oppiliappan

     

       0
        
       
     

       4
        
       

     

       5
        
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
        
       of this software and associated documentation files (the "Software"), to deal

···

       1
        
       MIT License

     

       2
        
       

     

       3
       +
       Copyright (c) 2025 Anirudh Oppiliappan, Akshay Oppiliappan and

     

       4
       +
       contributors.

     

       5
        
       

     

       6
        
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       7
        
       of this software and associated documentation files (the "Software"), to deal

types/tree.go

···

       8
        
       

     

       9
        
       // A nicer git tree representation.

     

       10
        
       type NiceTree struct {

     

       0
        
       
     

       11
        
       	Name      string `json:"name"`

     

       12
        
       	Mode      string `json:"mode"`

     

       13
        
       	Size      int64  `json:"size"`

···

       8
        
       

     

       9
        
       // A nicer git tree representation.

     

       10
        
       type NiceTree struct {

     

       11
       +
       	// Relative path

     

       12
        
       	Name      string `json:"name"`

     

       13
        
       	Mode      string `json:"mode"`

     

       14
        
       	Size      int64  `json:"size"`

+20

types/patch.go

···

       1
       +
       package types

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       

     

       6
       +
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type FormatPatch struct {

     

       10
       +
       	Files []*gitdiff.File

     

       11
       +
       	*gitdiff.PatchHeader

     

       12
       +
       	Raw string

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func (f FormatPatch) ChangeId() (string, error) {

     

       16
       +
       	if vals, ok := f.RawHeaders["Change-Id"]; ok && len(vals) == 1 {

     

       17
       +
       		return vals[0], nil

     

       18
       +
       	}

     

       19
       +
       	return "", fmt.Errorf("no change-id found")

     

       20
       +
       }

+45 -1

appview/resolver.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"context"

     

       0
        
       
     

       0
        
       
     

       5
        
       	"sync"

     

       0
        
       
     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       0
        
       
     

       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       0
        
       
     

       9
        
       )

     

       10
        
       

     

       11
        
       type Resolver struct {

     

       12
        
       	directory identity.Directory

     

       13
        
       }

     

       14
        
       

     

       15
       -
       func NewResolver() *Resolver {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       	return &Resolver{

     

       17
        
       		directory: identity.DefaultDirectory(),

     

       18
        
       	}

     

       19
        
       }

     

       20
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       21
        
       func (r *Resolver) ResolveIdent(ctx context.Context, arg string) (*identity.Identity, error) {

     

       22
        
       	id, err := syntax.ParseAtIdentifier(arg)

     

       23
        
       	if err != nil {

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"context"

     

       5
       +
       	"net"

     

       6
       +
       	"net/http"

     

       7
        
       	"sync"

     

       8
       +
       	"time"

     

       9
        
       

     

       10
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       11
       +
       	"github.com/bluesky-social/indigo/atproto/identity/redisdir"

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       +
       	"github.com/carlmjohnson/versioninfo"

     

       14
        
       )

     

       15
        
       

     

       16
        
       type Resolver struct {

     

       17
        
       	directory identity.Directory

     

       18
        
       }

     

       19
        
       

     

       20
       +
       func BaseDirectory() identity.Directory {

     

       21
       +
       	base := identity.BaseDirectory{

     

       22
       +
       		PLCURL: identity.DefaultPLCURL,

     

       23
       +
       		HTTPClient: http.Client{

     

       24
       +
       			Timeout: time.Second * 10,

     

       25
       +
       			Transport: &http.Transport{

     

       26
       +
       				// would want this around 100ms for services doing lots of handle resolution. Impacts PLC connections as well, but not too bad.

     

       27
       +
       				IdleConnTimeout: time.Millisecond * 1000,

     

       28
       +
       				MaxIdleConns:    100,

     

       29
       +
       			},

     

       30
       +
       		},

     

       31
       +
       		Resolver: net.Resolver{

     

       32
       +
       			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {

     

       33
       +
       				d := net.Dialer{Timeout: time.Second * 3}

     

       34
       +
       				return d.DialContext(ctx, network, address)

     

       35
       +
       			},

     

       36
       +
       		},

     

       37
       +
       		TryAuthoritativeDNS: true,

     

       38
       +
       		// primary Bluesky PDS instance only supports HTTP resolution method

     

       39
       +
       		SkipDNSDomainSuffixes: []string{".bsky.social"},

     

       40
       +
       		UserAgent:             "indigo-identity/" + versioninfo.Short(),

     

       41
       +
       	}

     

       42
       +
       	return &base

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       func RedisDirectory(url string) (identity.Directory, error) {

     

       46
       +
       	return redisdir.NewRedisDirectory(BaseDirectory(), url, time.Hour*24, time.Hour*1, time.Hour*1, 10000)

     

       47
       +
       }

     

       48
       +
       

     

       49
       +
       func DefaultResolver() *Resolver {

     

       50
        
       	return &Resolver{

     

       51
        
       		directory: identity.DefaultDirectory(),

     

       52
        
       	}

     

       53
        
       }

     

       54
        
       

     

       55
       +
       func RedisResolver(config RedisConfig) (*Resolver, error) {

     

       56
       +
       	directory, err := RedisDirectory(config.ToURL())

     

       57
       +
       	if err != nil {

     

       58
       +
       		return nil, err

     

       59
       +
       	}

     

       60
       +
       	return &Resolver{

     

       61
       +
       		directory: directory,

     

       62
       +
       	}, nil

     

       63
       +
       }

     

       64
       +
       

     

       65
        
       func (r *Resolver) ResolveIdent(ctx context.Context, arg string) (*identity.Identity, error) {

     

       66
        
       	id, err := syntax.ParseAtIdentifier(arg)

     

       67
        
       	if err != nil {

+6 -5

appview/state/artifact.go

···

       17
        
       	"tangled.sh/tangled.sh/core/appview"

     

       18
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       19
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       0
        
       
     

       20
        
       	"tangled.sh/tangled.sh/core/knotclient"

     

       21
        
       	"tangled.sh/tangled.sh/core/types"

     

       22
        
       )

     
···

       25
        
       func (s *State) AttachArtifact(w http.ResponseWriter, r *http.Request) {

     

       26
        
       	user := s.oauth.GetUser(r)

     

       27
        
       	tagParam := chi.URLParam(r, "tag")

     

       28
       -
       	f, err := s.fullyResolvedRepo(r)

     

       29
        
       	if err != nil {

     

       30
        
       		log.Println("failed to get repo and knot", err)

     

       31
        
       		s.pages.Notice(w, "upload", "failed to upload artifact, error in repo resolution")

     
···

       124
        
       

     

       125
        
       	s.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{

     

       126
        
       		LoggedInUser: user,

     

       127
       -
       		RepoInfo:     f.RepoInfo(s, user),

     

       128
        
       		Artifact:     artifact,

     

       129
        
       	})

     

       130
        
       }

     
···

       133
        
       func (s *State) DownloadArtifact(w http.ResponseWriter, r *http.Request) {

     

       134
        
       	tagParam := chi.URLParam(r, "tag")

     

       135
        
       	filename := chi.URLParam(r, "file")

     

       136
       -
       	f, err := s.fullyResolvedRepo(r)

     

       137
        
       	if err != nil {

     

       138
        
       		log.Println("failed to get repo and knot", err)

     

       139
        
       		return

     
···

       184
        
       	user := s.oauth.GetUser(r)

     

       185
        
       	tagParam := chi.URLParam(r, "tag")

     

       186
        
       	filename := chi.URLParam(r, "file")

     

       187
       -
       	f, err := s.fullyResolvedRepo(r)

     

       188
        
       	if err != nil {

     

       189
        
       		log.Println("failed to get repo and knot", err)

     

       190
        
       		return

     
···

       258
        
       	w.Write([]byte{})

     

       259
        
       }

     

       260
        
       

     

       261
       -
       func (s *State) resolveTag(f *FullyResolvedRepo, tagParam string) (*types.TagReference, error) {

     

       262
        
       	tagParam, err := url.QueryUnescape(tagParam)

     

       263
        
       	if err != nil {

     

       264
        
       		return nil, err

···

       17
        
       	"tangled.sh/tangled.sh/core/appview"

     

       18
        
       	"tangled.sh/tangled.sh/core/appview/db"

     

       19
        
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       20
       +
       	"tangled.sh/tangled.sh/core/appview/reporesolver"

     

       21
        
       	"tangled.sh/tangled.sh/core/knotclient"

     

       22
        
       	"tangled.sh/tangled.sh/core/types"

     

       23
        
       )

     
···

       26
        
       func (s *State) AttachArtifact(w http.ResponseWriter, r *http.Request) {

     

       27
        
       	user := s.oauth.GetUser(r)

     

       28
        
       	tagParam := chi.URLParam(r, "tag")

     

       29
       +
       	f, err := s.repoResolver.Resolve(r)

     

       30
        
       	if err != nil {

     

       31
        
       		log.Println("failed to get repo and knot", err)

     

       32
        
       		s.pages.Notice(w, "upload", "failed to upload artifact, error in repo resolution")

     
···

       125
        
       

     

       126
        
       	s.pages.RepoArtifactFragment(w, pages.RepoArtifactParams{

     

       127
        
       		LoggedInUser: user,

     

       128
       +
       		RepoInfo:     f.RepoInfo(user),

     

       129
        
       		Artifact:     artifact,

     

       130
        
       	})

     

       131
        
       }

     
···

       134
        
       func (s *State) DownloadArtifact(w http.ResponseWriter, r *http.Request) {

     

       135
        
       	tagParam := chi.URLParam(r, "tag")

     

       136
        
       	filename := chi.URLParam(r, "file")

     

       137
       +
       	f, err := s.repoResolver.Resolve(r)

     

       138
        
       	if err != nil {

     

       139
        
       		log.Println("failed to get repo and knot", err)

     

       140
        
       		return

     
···

       185
        
       	user := s.oauth.GetUser(r)

     

       186
        
       	tagParam := chi.URLParam(r, "tag")

     

       187
        
       	filename := chi.URLParam(r, "file")

     

       188
       +
       	f, err := s.repoResolver.Resolve(r)

     

       189
        
       	if err != nil {

     

       190
        
       		log.Println("failed to get repo and knot", err)

     

       191
        
       		return

     
···

       259
        
       	w.Write([]byte{})

     

       260
        
       }

     

       261
        
       

     

       262
       +
       func (s *State) resolveTag(f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) {

     

       263
        
       	tagParam, err := url.QueryUnescape(tagParam)

     

       264
        
       	if err != nil {

     

       265
        
       		return nil, err

-2093

appview/state/pull.go

···

       1
       -
       package state

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"database/sql"

     

       5
       -
       	"encoding/json"

     

       6
       -
       	"errors"

     

       7
       -
       	"fmt"

     

       8
       -
       	"io"

     

       9
       -
       	"log"

     

       10
       -
       	"net/http"

     

       11
       -
       	"sort"

     

       12
       -
       	"strconv"

     

       13
       -
       	"strings"

     

       14
       -
       	"time"

     

       15
       -
       

     

       16
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       17
       -
       	"tangled.sh/tangled.sh/core/appview"

     

       18
       -
       	"tangled.sh/tangled.sh/core/appview/db"

     

       19
       -
       	"tangled.sh/tangled.sh/core/appview/oauth"

     

       20
       -
       	"tangled.sh/tangled.sh/core/appview/pages"

     

       21
       -
       	"tangled.sh/tangled.sh/core/appview/reporesolver"

     

       22
       -
       	"tangled.sh/tangled.sh/core/knotclient"

     

       23
       -
       	"tangled.sh/tangled.sh/core/patchutil"

     

       24
       -
       	"tangled.sh/tangled.sh/core/types"

     

       25
       -
       

     

       26
       -
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       27
       -
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       28
       -
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       29
       -
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       30
       -
       	"github.com/go-chi/chi/v5"

     

       31
       -
       	"github.com/google/uuid"

     

       32
       -
       	"github.com/posthog/posthog-go"

     

       33
       -
       )

     

       34
       -
       

     

       35
       -
       // htmx fragment

     

       36
       -
       func (s *State) PullActions(w http.ResponseWriter, r *http.Request) {

     

       37
       -
       	switch r.Method {

     

       38
       -
       	case http.MethodGet:

     

       39
       -
       		user := s.oauth.GetUser(r)

     

       40
       -
       		f, err := s.repoResolver.Resolve(r)

     

       41
       -
       		if err != nil {

     

       42
       -
       			log.Println("failed to get repo and knot", err)

     

       43
       -
       			return

     

       44
       -
       		}

     

       45
       -
       

     

       46
       -
       		pull, ok := r.Context().Value("pull").(*db.Pull)

     

       47
       -
       		if !ok {

     

       48
       -
       			log.Println("failed to get pull")

     

       49
       -
       			s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       50
       -
       			return

     

       51
       -
       		}

     

       52
       -
       

     

       53
       -
       		// can be nil  if this pull is not stacked

     

       54
       -
       		stack, _ := r.Context().Value("stack").(db.Stack)

     

       55
       -
       

     

       56
       -
       		roundNumberStr := chi.URLParam(r, "round")

     

       57
       -
       		roundNumber, err := strconv.Atoi(roundNumberStr)

     

       58
       -
       		if err != nil {

     

       59
       -
       			roundNumber = pull.LastRoundNumber()

     

       60
       -
       		}

     

       61
       -
       		if roundNumber >= len(pull.Submissions) {

     

       62
       -
       			http.Error(w, "bad round id", http.StatusBadRequest)

     

       63
       -
       			log.Println("failed to parse round id", err)

     

       64
       -
       			return

     

       65
       -
       		}

     

       66
       -
       

     

       67
       -
       		mergeCheckResponse := s.mergeCheck(f, pull, stack)

     

       68
       -
       		resubmitResult := pages.Unknown

     

       69
       -
       		if user.Did == pull.OwnerDid {

     

       70
       -
       			resubmitResult = s.resubmitCheck(f, pull, stack)

     

       71
       -
       		}

     

       72
       -
       

     

       73
       -
       		s.pages.PullActionsFragment(w, pages.PullActionsParams{

     

       74
       -
       			LoggedInUser:  user,

     

       75
       -
       			RepoInfo:      f.RepoInfo(user),

     

       76
       -
       			Pull:          pull,

     

       77
       -
       			RoundNumber:   roundNumber,

     

       78
       -
       			MergeCheck:    mergeCheckResponse,

     

       79
       -
       			ResubmitCheck: resubmitResult,

     

       80
       -
       			Stack:         stack,

     

       81
       -
       		})

     

       82
       -
       		return

     

       83
       -
       	}

     

       84
       -
       }

     

       85
       -
       

     

       86
       -
       func (s *State) RepoSinglePull(w http.ResponseWriter, r *http.Request) {

     

       87
       -
       	user := s.oauth.GetUser(r)

     

       88
       -
       	f, err := s.repoResolver.Resolve(r)

     

       89
       -
       	if err != nil {

     

       90
       -
       		log.Println("failed to get repo and knot", err)

     

       91
       -
       		return

     

       92
       -
       	}

     

       93
       -
       

     

       94
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       95
       -
       	if !ok {

     

       96
       -
       		log.Println("failed to get pull")

     

       97
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       98
       -
       		return

     

       99
       -
       	}

     

       100
       -
       

     

       101
       -
       	// can be nil  if this pull is not stacked

     

       102
       -
       	stack, _ := r.Context().Value("stack").(db.Stack)

     

       103
       -
       	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*db.Pull)

     

       104
       -
       

     

       105
       -
       	totalIdents := 1

     

       106
       -
       	for _, submission := range pull.Submissions {

     

       107
       -
       		totalIdents += len(submission.Comments)

     

       108
       -
       	}

     

       109
       -
       

     

       110
       -
       	identsToResolve := make([]string, totalIdents)

     

       111
       -
       

     

       112
       -
       	// populate idents

     

       113
       -
       	identsToResolve[0] = pull.OwnerDid

     

       114
       -
       	idx := 1

     

       115
       -
       	for _, submission := range pull.Submissions {

     

       116
       -
       		for _, comment := range submission.Comments {

     

       117
       -
       			identsToResolve[idx] = comment.OwnerDid

     

       118
       -
       			idx += 1

     

       119
       -
       		}

     

       120
       -
       	}

     

       121
       -
       

     

       122
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       123
       -
       	didHandleMap := make(map[string]string)

     

       124
       -
       	for _, identity := range resolvedIds {

     

       125
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       126
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       127
       -
       		} else {

     

       128
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       129
       -
       		}

     

       130
       -
       	}

     

       131
       -
       

     

       132
       -
       	mergeCheckResponse := s.mergeCheck(f, pull, stack)

     

       133
       -
       	resubmitResult := pages.Unknown

     

       134
       -
       	if user != nil && user.Did == pull.OwnerDid {

     

       135
       -
       		resubmitResult = s.resubmitCheck(f, pull, stack)

     

       136
       -
       	}

     

       137
       -
       

     

       138
       -
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       139
       -
       		LoggedInUser:   user,

     

       140
       -
       		RepoInfo:       f.RepoInfo(user),

     

       141
       -
       		DidHandleMap:   didHandleMap,

     

       142
       -
       		Pull:           pull,

     

       143
       -
       		Stack:          stack,

     

       144
       -
       		AbandonedPulls: abandonedPulls,

     

       145
       -
       		MergeCheck:     mergeCheckResponse,

     

       146
       -
       		ResubmitCheck:  resubmitResult,

     

       147
       -
       	})

     

       148
       -
       }

     

       149
       -
       

     

       150
       -
       func (s *State) mergeCheck(f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) types.MergeCheckResponse {

     

       151
       -
       	if pull.State == db.PullMerged {

     

       152
       -
       		return types.MergeCheckResponse{}

     

       153
       -
       	}

     

       154
       -
       

     

       155
       -
       	secret, err := db.GetRegistrationKey(s.db, f.Knot)

     

       156
       -
       	if err != nil {

     

       157
       -
       		log.Printf("failed to get registration key: %v", err)

     

       158
       -
       		return types.MergeCheckResponse{

     

       159
       -
       			Error: "failed to check merge status: this knot is unregistered",

     

       160
       -
       		}

     

       161
       -
       	}

     

       162
       -
       

     

       163
       -
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       164
       -
       	if err != nil {

     

       165
       -
       		log.Printf("failed to setup signed client for %s; ignoring: %v", f.Knot, err)

     

       166
       -
       		return types.MergeCheckResponse{

     

       167
       -
       			Error: "failed to check merge status",

     

       168
       -
       		}

     

       169
       -
       	}

     

       170
       -
       

     

       171
       -
       	patch := pull.LatestPatch()

     

       172
       -
       	if pull.IsStacked() {

     

       173
       -
       		// combine patches of substack

     

       174
       -
       		subStack := stack.Below(pull)

     

       175
       -
       		// collect the portion of the stack that is mergeable

     

       176
       -
       		mergeable := subStack.Mergeable()

     

       177
       -
       		// combine each patch

     

       178
       -
       		patch = mergeable.CombinedPatch()

     

       179
       -
       	}

     

       180
       -
       

     

       181
       -
       	resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch)

     

       182
       -
       	if err != nil {

     

       183
       -
       		log.Println("failed to check for mergeability:", err)

     

       184
       -
       		return types.MergeCheckResponse{

     

       185
       -
       			Error: "failed to check merge status",

     

       186
       -
       		}

     

       187
       -
       	}

     

       188
       -
       	switch resp.StatusCode {

     

       189
       -
       	case 404:

     

       190
       -
       		return types.MergeCheckResponse{

     

       191
       -
       			Error: "failed to check merge status: this knot does not support PRs",

     

       192
       -
       		}

     

       193
       -
       	case 400:

     

       194
       -
       		return types.MergeCheckResponse{

     

       195
       -
       			Error: "failed to check merge status: does this knot support PRs?",

     

       196
       -
       		}

     

       197
       -
       	}

     

       198
       -
       

     

       199
       -
       	respBody, err := io.ReadAll(resp.Body)

     

       200
       -
       	if err != nil {

     

       201
       -
       		log.Println("failed to read merge check response body")

     

       202
       -
       		return types.MergeCheckResponse{

     

       203
       -
       			Error: "failed to check merge status: knot is not speaking the right language",

     

       204
       -
       		}

     

       205
       -
       	}

     

       206
       -
       	defer resp.Body.Close()

     

       207
       -
       

     

       208
       -
       	var mergeCheckResponse types.MergeCheckResponse

     

       209
       -
       	err = json.Unmarshal(respBody, &mergeCheckResponse)

     

       210
       -
       	if err != nil {

     

       211
       -
       		log.Println("failed to unmarshal merge check response", err)

     

       212
       -
       		return types.MergeCheckResponse{

     

       213
       -
       			Error: "failed to check merge status: knot is not speaking the right language",

     

       214
       -
       		}

     

       215
       -
       	}

     

       216
       -
       

     

       217
       -
       	return mergeCheckResponse

     

       218
       -
       }

     

       219
       -
       

     

       220
       -
       func (s *State) resubmitCheck(f *reporesolver.ResolvedRepo, pull *db.Pull, stack db.Stack) pages.ResubmitResult {

     

       221
       -
       	if pull.State == db.PullMerged || pull.State == db.PullDeleted || pull.PullSource == nil {

     

       222
       -
       		return pages.Unknown

     

       223
       -
       	}

     

       224
       -
       

     

       225
       -
       	var knot, ownerDid, repoName string

     

       226
       -
       

     

       227
       -
       	if pull.PullSource.RepoAt != nil {

     

       228
       -
       		// fork-based pulls

     

       229
       -
       		sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())

     

       230
       -
       		if err != nil {

     

       231
       -
       			log.Println("failed to get source repo", err)

     

       232
       -
       			return pages.Unknown

     

       233
       -
       		}

     

       234
       -
       

     

       235
       -
       		knot = sourceRepo.Knot

     

       236
       -
       		ownerDid = sourceRepo.Did

     

       237
       -
       		repoName = sourceRepo.Name

     

       238
       -
       	} else {

     

       239
       -
       		// pulls within the same repo

     

       240
       -
       		knot = f.Knot

     

       241
       -
       		ownerDid = f.OwnerDid()

     

       242
       -
       		repoName = f.RepoName

     

       243
       -
       	}

     

       244
       -
       

     

       245
       -
       	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)

     

       246
       -
       	if err != nil {

     

       247
       -
       		log.Printf("failed to setup client for %s; ignoring: %v", knot, err)

     

       248
       -
       		return pages.Unknown

     

       249
       -
       	}

     

       250
       -
       

     

       251
       -
       	result, err := us.Branch(ownerDid, repoName, pull.PullSource.Branch)

     

       252
       -
       	if err != nil {

     

       253
       -
       		log.Println("failed to reach knotserver", err)

     

       254
       -
       		return pages.Unknown

     

       255
       -
       	}

     

       256
       -
       

     

       257
       -
       	latestSourceRev := pull.Submissions[pull.LastRoundNumber()].SourceRev

     

       258
       -
       

     

       259
       -
       	if pull.IsStacked() && stack != nil {

     

       260
       -
       		top := stack[0]

     

       261
       -
       		latestSourceRev = top.Submissions[top.LastRoundNumber()].SourceRev

     

       262
       -
       	}

     

       263
       -
       

     

       264
       -
       	log.Println(latestSourceRev, result.Branch.Hash)

     

       265
       -
       

     

       266
       -
       	if latestSourceRev != result.Branch.Hash {

     

       267
       -
       		return pages.ShouldResubmit

     

       268
       -
       	}

     

       269
       -
       

     

       270
       -
       	return pages.ShouldNotResubmit

     

       271
       -
       }

     

       272
       -
       

     

       273
       -
       func (s *State) RepoPullPatch(w http.ResponseWriter, r *http.Request) {

     

       274
       -
       	user := s.oauth.GetUser(r)

     

       275
       -
       	f, err := s.repoResolver.Resolve(r)

     

       276
       -
       	if err != nil {

     

       277
       -
       		log.Println("failed to get repo and knot", err)

     

       278
       -
       		return

     

       279
       -
       	}

     

       280
       -
       

     

       281
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       282
       -
       	if !ok {

     

       283
       -
       		log.Println("failed to get pull")

     

       284
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       285
       -
       		return

     

       286
       -
       	}

     

       287
       -
       

     

       288
       -
       	stack, _ := r.Context().Value("stack").(db.Stack)

     

       289
       -
       

     

       290
       -
       	roundId := chi.URLParam(r, "round")

     

       291
       -
       	roundIdInt, err := strconv.Atoi(roundId)

     

       292
       -
       	if err != nil || roundIdInt >= len(pull.Submissions) {

     

       293
       -
       		http.Error(w, "bad round id", http.StatusBadRequest)

     

       294
       -
       		log.Println("failed to parse round id", err)

     

       295
       -
       		return

     

       296
       -
       	}

     

       297
       -
       

     

       298
       -
       	identsToResolve := []string{pull.OwnerDid}

     

       299
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       300
       -
       	didHandleMap := make(map[string]string)

     

       301
       -
       	for _, identity := range resolvedIds {

     

       302
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       303
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       304
       -
       		} else {

     

       305
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       306
       -
       		}

     

       307
       -
       	}

     

       308
       -
       

     

       309
       -
       	patch := pull.Submissions[roundIdInt].Patch

     

       310
       -
       	diff := patchutil.AsNiceDiff(patch, pull.TargetBranch)

     

       311
       -
       

     

       312
       -
       	s.pages.RepoPullPatchPage(w, pages.RepoPullPatchParams{

     

       313
       -
       		LoggedInUser: user,

     

       314
       -
       		DidHandleMap: didHandleMap,

     

       315
       -
       		RepoInfo:     f.RepoInfo(user),

     

       316
       -
       		Pull:         pull,

     

       317
       -
       		Stack:        stack,

     

       318
       -
       		Round:        roundIdInt,

     

       319
       -
       		Submission:   pull.Submissions[roundIdInt],

     

       320
       -
       		Diff:         &diff,

     

       321
       -
       	})

     

       322
       -
       

     

       323
       -
       }

     

       324
       -
       

     

       325
       -
       func (s *State) RepoPullInterdiff(w http.ResponseWriter, r *http.Request) {

     

       326
       -
       	user := s.oauth.GetUser(r)

     

       327
       -
       

     

       328
       -
       	f, err := s.repoResolver.Resolve(r)

     

       329
       -
       	if err != nil {

     

       330
       -
       		log.Println("failed to get repo and knot", err)

     

       331
       -
       		return

     

       332
       -
       	}

     

       333
       -
       

     

       334
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       335
       -
       	if !ok {

     

       336
       -
       		log.Println("failed to get pull")

     

       337
       -
       		s.pages.Notice(w, "pull-error", "Failed to get pull.")

     

       338
       -
       		return

     

       339
       -
       	}

     

       340
       -
       

     

       341
       -
       	roundId := chi.URLParam(r, "round")

     

       342
       -
       	roundIdInt, err := strconv.Atoi(roundId)

     

       343
       -
       	if err != nil || roundIdInt >= len(pull.Submissions) {

     

       344
       -
       		http.Error(w, "bad round id", http.StatusBadRequest)

     

       345
       -
       		log.Println("failed to parse round id", err)

     

       346
       -
       		return

     

       347
       -
       	}

     

       348
       -
       

     

       349
       -
       	if roundIdInt == 0 {

     

       350
       -
       		http.Error(w, "bad round id", http.StatusBadRequest)

     

       351
       -
       		log.Println("cannot interdiff initial submission")

     

       352
       -
       		return

     

       353
       -
       	}

     

       354
       -
       

     

       355
       -
       	identsToResolve := []string{pull.OwnerDid}

     

       356
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       357
       -
       	didHandleMap := make(map[string]string)

     

       358
       -
       	for _, identity := range resolvedIds {

     

       359
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       360
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       361
       -
       		} else {

     

       362
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       363
       -
       		}

     

       364
       -
       	}

     

       365
       -
       

     

       366
       -
       	currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].Patch)

     

       367
       -
       	if err != nil {

     

       368
       -
       		log.Println("failed to interdiff; current patch malformed")

     

       369
       -
       		s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.")

     

       370
       -
       		return

     

       371
       -
       	}

     

       372
       -
       

     

       373
       -
       	previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].Patch)

     

       374
       -
       	if err != nil {

     

       375
       -
       		log.Println("failed to interdiff; previous patch malformed")

     

       376
       -
       		s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.")

     

       377
       -
       		return

     

       378
       -
       	}

     

       379
       -
       

     

       380
       -
       	interdiff := patchutil.Interdiff(previousPatch, currentPatch)

     

       381
       -
       

     

       382
       -
       	s.pages.RepoPullInterdiffPage(w, pages.RepoPullInterdiffParams{

     

       383
       -
       		LoggedInUser: s.oauth.GetUser(r),

     

       384
       -
       		RepoInfo:     f.RepoInfo(user),

     

       385
       -
       		Pull:         pull,

     

       386
       -
       		Round:        roundIdInt,

     

       387
       -
       		DidHandleMap: didHandleMap,

     

       388
       -
       		Interdiff:    interdiff,

     

       389
       -
       	})

     

       390
       -
       	return

     

       391
       -
       }

     

       392
       -
       

     

       393
       -
       func (s *State) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) {

     

       394
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       395
       -
       	if !ok {

     

       396
       -
       		log.Println("failed to get pull")

     

       397
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       398
       -
       		return

     

       399
       -
       	}

     

       400
       -
       

     

       401
       -
       	roundId := chi.URLParam(r, "round")

     

       402
       -
       	roundIdInt, err := strconv.Atoi(roundId)

     

       403
       -
       	if err != nil || roundIdInt >= len(pull.Submissions) {

     

       404
       -
       		http.Error(w, "bad round id", http.StatusBadRequest)

     

       405
       -
       		log.Println("failed to parse round id", err)

     

       406
       -
       		return

     

       407
       -
       	}

     

       408
       -
       

     

       409
       -
       	identsToResolve := []string{pull.OwnerDid}

     

       410
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       411
       -
       	didHandleMap := make(map[string]string)

     

       412
       -
       	for _, identity := range resolvedIds {

     

       413
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       414
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       415
       -
       		} else {

     

       416
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       417
       -
       		}

     

       418
       -
       	}

     

       419
       -
       

     

       420
       -
       	w.Header().Set("Content-Type", "text/plain")

     

       421
       -
       	w.Write([]byte(pull.Submissions[roundIdInt].Patch))

     

       422
       -
       }

     

       423
       -
       

     

       424
       -
       func (s *State) RepoPulls(w http.ResponseWriter, r *http.Request) {

     

       425
       -
       	user := s.oauth.GetUser(r)

     

       426
       -
       	params := r.URL.Query()

     

       427
       -
       

     

       428
       -
       	state := db.PullOpen

     

       429
       -
       	switch params.Get("state") {

     

       430
       -
       	case "closed":

     

       431
       -
       		state = db.PullClosed

     

       432
       -
       	case "merged":

     

       433
       -
       		state = db.PullMerged

     

       434
       -
       	}

     

       435
       -
       

     

       436
       -
       	f, err := s.repoResolver.Resolve(r)

     

       437
       -
       	if err != nil {

     

       438
       -
       		log.Println("failed to get repo and knot", err)

     

       439
       -
       		return

     

       440
       -
       	}

     

       441
       -
       

     

       442
       -
       	pulls, err := db.GetPulls(

     

       443
       -
       		s.db,

     

       444
       -
       		db.FilterEq("repo_at", f.RepoAt),

     

       445
       -
       		db.FilterEq("state", state),

     

       446
       -
       	)

     

       447
       -
       	if err != nil {

     

       448
       -
       		log.Println("failed to get pulls", err)

     

       449
       -
       		s.pages.Notice(w, "pulls", "Failed to load pulls. Try again later.")

     

       450
       -
       		return

     

       451
       -
       	}

     

       452
       -
       

     

       453
       -
       	for _, p := range pulls {

     

       454
       -
       		var pullSourceRepo *db.Repo

     

       455
       -
       		if p.PullSource != nil {

     

       456
       -
       			if p.PullSource.RepoAt != nil {

     

       457
       -
       				pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())

     

       458
       -
       				if err != nil {

     

       459
       -
       					log.Printf("failed to get repo by at uri: %v", err)

     

       460
       -
       					continue

     

       461
       -
       				} else {

     

       462
       -
       					p.PullSource.Repo = pullSourceRepo

     

       463
       -
       				}

     

       464
       -
       			}

     

       465
       -
       		}

     

       466
       -
       	}

     

       467
       -
       

     

       468
       -
       	identsToResolve := make([]string, len(pulls))

     

       469
       -
       	for i, pull := range pulls {

     

       470
       -
       		identsToResolve[i] = pull.OwnerDid

     

       471
       -
       	}

     

       472
       -
       	resolvedIds := s.resolver.ResolveIdents(r.Context(), identsToResolve)

     

       473
       -
       	didHandleMap := make(map[string]string)

     

       474
       -
       	for _, identity := range resolvedIds {

     

       475
       -
       		if !identity.Handle.IsInvalidHandle() {

     

       476
       -
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       477
       -
       		} else {

     

       478
       -
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       479
       -
       		}

     

       480
       -
       	}

     

       481
       -
       

     

       482
       -
       	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       483
       -
       		LoggedInUser: s.oauth.GetUser(r),

     

       484
       -
       		RepoInfo:     f.RepoInfo(user),

     

       485
       -
       		Pulls:        pulls,

     

       486
       -
       		DidHandleMap: didHandleMap,

     

       487
       -
       		FilteringBy:  state,

     

       488
       -
       	})

     

       489
       -
       	return

     

       490
       -
       }

     

       491
       -
       

     

       492
       -
       func (s *State) PullComment(w http.ResponseWriter, r *http.Request) {

     

       493
       -
       	user := s.oauth.GetUser(r)

     

       494
       -
       	f, err := s.repoResolver.Resolve(r)

     

       495
       -
       	if err != nil {

     

       496
       -
       		log.Println("failed to get repo and knot", err)

     

       497
       -
       		return

     

       498
       -
       	}

     

       499
       -
       

     

       500
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       501
       -
       	if !ok {

     

       502
       -
       		log.Println("failed to get pull")

     

       503
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       504
       -
       		return

     

       505
       -
       	}

     

       506
       -
       

     

       507
       -
       	roundNumberStr := chi.URLParam(r, "round")

     

       508
       -
       	roundNumber, err := strconv.Atoi(roundNumberStr)

     

       509
       -
       	if err != nil || roundNumber >= len(pull.Submissions) {

     

       510
       -
       		http.Error(w, "bad round id", http.StatusBadRequest)

     

       511
       -
       		log.Println("failed to parse round id", err)

     

       512
       -
       		return

     

       513
       -
       	}

     

       514
       -
       

     

       515
       -
       	switch r.Method {

     

       516
       -
       	case http.MethodGet:

     

       517
       -
       		s.pages.PullNewCommentFragment(w, pages.PullNewCommentParams{

     

       518
       -
       			LoggedInUser: user,

     

       519
       -
       			RepoInfo:     f.RepoInfo(user),

     

       520
       -
       			Pull:         pull,

     

       521
       -
       			RoundNumber:  roundNumber,

     

       522
       -
       		})

     

       523
       -
       		return

     

       524
       -
       	case http.MethodPost:

     

       525
       -
       		body := r.FormValue("body")

     

       526
       -
       		if body == "" {

     

       527
       -
       			s.pages.Notice(w, "pull", "Comment body is required")

     

       528
       -
       			return

     

       529
       -
       		}

     

       530
       -
       

     

       531
       -
       		// Start a transaction

     

       532
       -
       		tx, err := s.db.BeginTx(r.Context(), nil)

     

       533
       -
       		if err != nil {

     

       534
       -
       			log.Println("failed to start transaction", err)

     

       535
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       536
       -
       			return

     

       537
       -
       		}

     

       538
       -
       		defer tx.Rollback()

     

       539
       -
       

     

       540
       -
       		createdAt := time.Now().Format(time.RFC3339)

     

       541
       -
       		ownerDid := user.Did

     

       542
       -
       

     

       543
       -
       		pullAt, err := db.GetPullAt(s.db, f.RepoAt, pull.PullId)

     

       544
       -
       		if err != nil {

     

       545
       -
       			log.Println("failed to get pull at", err)

     

       546
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       547
       -
       			return

     

       548
       -
       		}

     

       549
       -
       

     

       550
       -
       		atUri := f.RepoAt.String()

     

       551
       -
       		client, err := s.oauth.AuthorizedClient(r)

     

       552
       -
       		if err != nil {

     

       553
       -
       			log.Println("failed to get authorized client", err)

     

       554
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       555
       -
       			return

     

       556
       -
       		}

     

       557
       -
       		atResp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       558
       -
       			Collection: tangled.RepoPullCommentNSID,

     

       559
       -
       			Repo:       user.Did,

     

       560
       -
       			Rkey:       appview.TID(),

     

       561
       -
       			Record: &lexutil.LexiconTypeDecoder{

     

       562
       -
       				Val: &tangled.RepoPullComment{

     

       563
       -
       					Repo:      &atUri,

     

       564
       -
       					Pull:      string(pullAt),

     

       565
       -
       					Owner:     &ownerDid,

     

       566
       -
       					Body:      body,

     

       567
       -
       					CreatedAt: createdAt,

     

       568
       -
       				},

     

       569
       -
       			},

     

       570
       -
       		})

     

       571
       -
       		if err != nil {

     

       572
       -
       			log.Println("failed to create pull comment", err)

     

       573
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       574
       -
       			return

     

       575
       -
       		}

     

       576
       -
       

     

       577
       -
       		// Create the pull comment in the database with the commentAt field

     

       578
       -
       		commentId, err := db.NewPullComment(tx, &db.PullComment{

     

       579
       -
       			OwnerDid:     user.Did,

     

       580
       -
       			RepoAt:       f.RepoAt.String(),

     

       581
       -
       			PullId:       pull.PullId,

     

       582
       -
       			Body:         body,

     

       583
       -
       			CommentAt:    atResp.Uri,

     

       584
       -
       			SubmissionId: pull.Submissions[roundNumber].ID,

     

       585
       -
       		})

     

       586
       -
       		if err != nil {

     

       587
       -
       			log.Println("failed to create pull comment", err)

     

       588
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       589
       -
       			return

     

       590
       -
       		}

     

       591
       -
       

     

       592
       -
       		// Commit the transaction

     

       593
       -
       		if err = tx.Commit(); err != nil {

     

       594
       -
       			log.Println("failed to commit transaction", err)

     

       595
       -
       			s.pages.Notice(w, "pull-comment", "Failed to create comment.")

     

       596
       -
       			return

     

       597
       -
       		}

     

       598
       -
       

     

       599
       -
       		if !s.config.Core.Dev {

     

       600
       -
       			err = s.posthog.Enqueue(posthog.Capture{

     

       601
       -
       				DistinctId: user.Did,

     

       602
       -
       				Event:      "new_pull_comment",

     

       603
       -
       				Properties: posthog.Properties{"repo_at": f.RepoAt.String(), "pull_id": pull.PullId},

     

       604
       -
       			})

     

       605
       -
       			if err != nil {

     

       606
       -
       				log.Println("failed to enqueue posthog event:", err)

     

       607
       -
       			}

     

       608
       -
       		}

     

       609
       -
       

     

       610
       -
       		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", f.OwnerSlashRepo(), pull.PullId, commentId))

     

       611
       -
       		return

     

       612
       -
       	}

     

       613
       -
       }

     

       614
       -
       

     

       615
       -
       func (s *State) NewPull(w http.ResponseWriter, r *http.Request) {

     

       616
       -
       	user := s.oauth.GetUser(r)

     

       617
       -
       	f, err := s.repoResolver.Resolve(r)

     

       618
       -
       	if err != nil {

     

       619
       -
       		log.Println("failed to get repo and knot", err)

     

       620
       -
       		return

     

       621
       -
       	}

     

       622
       -
       

     

       623
       -
       	switch r.Method {

     

       624
       -
       	case http.MethodGet:

     

       625
       -
       		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       626
       -
       		if err != nil {

     

       627
       -
       			log.Printf("failed to create unsigned client for %s", f.Knot)

     

       628
       -
       			s.pages.Error503(w)

     

       629
       -
       			return

     

       630
       -
       		}

     

       631
       -
       

     

       632
       -
       		result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       633
       -
       		if err != nil {

     

       634
       -
       			log.Println("failed to fetch branches", err)

     

       635
       -
       			return

     

       636
       -
       		}

     

       637
       -
       

     

       638
       -
       		// can be one of "patch", "branch" or "fork"

     

       639
       -
       		strategy := r.URL.Query().Get("strategy")

     

       640
       -
       		// ignored if strategy is "patch"

     

       641
       -
       		sourceBranch := r.URL.Query().Get("sourceBranch")

     

       642
       -
       		targetBranch := r.URL.Query().Get("targetBranch")

     

       643
       -
       

     

       644
       -
       		s.pages.RepoNewPull(w, pages.RepoNewPullParams{

     

       645
       -
       			LoggedInUser: user,

     

       646
       -
       			RepoInfo:     f.RepoInfo(user),

     

       647
       -
       			Branches:     result.Branches,

     

       648
       -
       			Strategy:     strategy,

     

       649
       -
       			SourceBranch: sourceBranch,

     

       650
       -
       			TargetBranch: targetBranch,

     

       651
       -
       			Title:        r.URL.Query().Get("title"),

     

       652
       -
       			Body:         r.URL.Query().Get("body"),

     

       653
       -
       		})

     

       654
       -
       

     

       655
       -
       	case http.MethodPost:

     

       656
       -
       		title := r.FormValue("title")

     

       657
       -
       		body := r.FormValue("body")

     

       658
       -
       		targetBranch := r.FormValue("targetBranch")

     

       659
       -
       		fromFork := r.FormValue("fork")

     

       660
       -
       		sourceBranch := r.FormValue("sourceBranch")

     

       661
       -
       		patch := r.FormValue("patch")

     

       662
       -
       

     

       663
       -
       		if targetBranch == "" {

     

       664
       -
       			s.pages.Notice(w, "pull", "Target branch is required.")

     

       665
       -
       			return

     

       666
       -
       		}

     

       667
       -
       

     

       668
       -
       		// Determine PR type based on input parameters

     

       669
       -
       		isPushAllowed := f.RepoInfo(user).Roles.IsPushAllowed()

     

       670
       -
       		isBranchBased := isPushAllowed && sourceBranch != "" && fromFork == ""

     

       671
       -
       		isForkBased := fromFork != "" && sourceBranch != ""

     

       672
       -
       		isPatchBased := patch != "" && !isBranchBased && !isForkBased

     

       673
       -
       		isStacked := r.FormValue("isStacked") == "on"

     

       674
       -
       

     

       675
       -
       		if isPatchBased && !patchutil.IsFormatPatch(patch) {

     

       676
       -
       			if title == "" {

     

       677
       -
       				s.pages.Notice(w, "pull", "Title is required for git-diff patches.")

     

       678
       -
       				return

     

       679
       -
       			}

     

       680
       -
       		}

     

       681
       -
       

     

       682
       -
       		// Validate we have at least one valid PR creation method

     

       683
       -
       		if !isBranchBased && !isPatchBased && !isForkBased {

     

       684
       -
       			s.pages.Notice(w, "pull", "Neither source branch nor patch supplied.")

     

       685
       -
       			return

     

       686
       -
       		}

     

       687
       -
       

     

       688
       -
       		// Can't mix branch-based and patch-based approaches

     

       689
       -
       		if isBranchBased && patch != "" {

     

       690
       -
       			s.pages.Notice(w, "pull", "Cannot select both patch and source branch.")

     

       691
       -
       			return

     

       692
       -
       		}

     

       693
       -
       

     

       694
       -
       		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       695
       -
       		if err != nil {

     

       696
       -
       			log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)

     

       697
       -
       			s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")

     

       698
       -
       			return

     

       699
       -
       		}

     

       700
       -
       

     

       701
       -
       		caps, err := us.Capabilities()

     

       702
       -
       		if err != nil {

     

       703
       -
       			log.Println("error fetching knot caps", f.Knot, err)

     

       704
       -
       			s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")

     

       705
       -
       			return

     

       706
       -
       		}

     

       707
       -
       

     

       708
       -
       		if !caps.PullRequests.FormatPatch {

     

       709
       -
       			s.pages.Notice(w, "pull", "This knot doesn't support format-patch. Unfortunately, there is no fallback for now.")

     

       710
       -
       			return

     

       711
       -
       		}

     

       712
       -
       

     

       713
       -
       		// Handle the PR creation based on the type

     

       714
       -
       		if isBranchBased {

     

       715
       -
       			if !caps.PullRequests.BranchSubmissions {

     

       716
       -
       				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")

     

       717
       -
       				return

     

       718
       -
       			}

     

       719
       -
       			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)

     

       720
       -
       		} else if isForkBased {

     

       721
       -
       			if !caps.PullRequests.ForkSubmissions {

     

       722
       -
       				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")

     

       723
       -
       				return

     

       724
       -
       			}

     

       725
       -
       			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)

     

       726
       -
       		} else if isPatchBased {

     

       727
       -
       			if !caps.PullRequests.PatchSubmissions {

     

       728
       -
       				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")

     

       729
       -
       				return

     

       730
       -
       			}

     

       731
       -
       			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)

     

       732
       -
       		}

     

       733
       -
       		return

     

       734
       -
       	}

     

       735
       -
       }

     

       736
       -
       

     

       737
       -
       func (s *State) handleBranchBasedPull(

     

       738
       -
       	w http.ResponseWriter,

     

       739
       -
       	r *http.Request,

     

       740
       -
       	f *reporesolver.ResolvedRepo,

     

       741
       -
       	user *oauth.User,

     

       742
       -
       	title,

     

       743
       -
       	body,

     

       744
       -
       	targetBranch,

     

       745
       -
       	sourceBranch string,

     

       746
       -
       	isStacked bool,

     

       747
       -
       ) {

     

       748
       -
       	pullSource := &db.PullSource{

     

       749
       -
       		Branch: sourceBranch,

     

       750
       -
       	}

     

       751
       -
       	recordPullSource := &tangled.RepoPull_Source{

     

       752
       -
       		Branch: sourceBranch,

     

       753
       -
       	}

     

       754
       -
       

     

       755
       -
       	// Generate a patch using /compare

     

       756
       -
       	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       757
       -
       	if err != nil {

     

       758
       -
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       759
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       760
       -
       		return

     

       761
       -
       	}

     

       762
       -
       

     

       763
       -
       	comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch)

     

       764
       -
       	if err != nil {

     

       765
       -
       		log.Println("failed to compare", err)

     

       766
       -
       		s.pages.Notice(w, "pull", err.Error())

     

       767
       -
       		return

     

       768
       -
       	}

     

       769
       -
       

     

       770
       -
       	sourceRev := comparison.Rev2

     

       771
       -
       	patch := comparison.Patch

     

       772
       -
       

     

       773
       -
       	if !patchutil.IsPatchValid(patch) {

     

       774
       -
       		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       775
       -
       		return

     

       776
       -
       	}

     

       777
       -
       

     

       778
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked)

     

       779
       -
       }

     

       780
       -
       

     

       781
       -
       func (s *State) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) {

     

       782
       -
       	if !patchutil.IsPatchValid(patch) {

     

       783
       -
       		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       784
       -
       		return

     

       785
       -
       	}

     

       786
       -
       

     

       787
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", nil, nil, isStacked)

     

       788
       -
       }

     

       789
       -
       

     

       790
       -
       func (s *State) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) {

     

       791
       -
       	fork, err := db.GetForkByDid(s.db, user.Did, forkRepo)

     

       792
       -
       	if errors.Is(err, sql.ErrNoRows) {

     

       793
       -
       		s.pages.Notice(w, "pull", "No such fork.")

     

       794
       -
       		return

     

       795
       -
       	} else if err != nil {

     

       796
       -
       		log.Println("failed to fetch fork:", err)

     

       797
       -
       		s.pages.Notice(w, "pull", "Failed to fetch fork.")

     

       798
       -
       		return

     

       799
       -
       	}

     

       800
       -
       

     

       801
       -
       	secret, err := db.GetRegistrationKey(s.db, fork.Knot)

     

       802
       -
       	if err != nil {

     

       803
       -
       		log.Println("failed to fetch registration key:", err)

     

       804
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       805
       -
       		return

     

       806
       -
       	}

     

       807
       -
       

     

       808
       -
       	sc, err := knotclient.NewSignedClient(fork.Knot, secret, s.config.Core.Dev)

     

       809
       -
       	if err != nil {

     

       810
       -
       		log.Println("failed to create signed client:", err)

     

       811
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       812
       -
       		return

     

       813
       -
       	}

     

       814
       -
       

     

       815
       -
       	us, err := knotclient.NewUnsignedClient(fork.Knot, s.config.Core.Dev)

     

       816
       -
       	if err != nil {

     

       817
       -
       		log.Println("failed to create unsigned client:", err)

     

       818
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       819
       -
       		return

     

       820
       -
       	}

     

       821
       -
       

     

       822
       -
       	resp, err := sc.NewHiddenRef(user.Did, fork.Name, sourceBranch, targetBranch)

     

       823
       -
       	if err != nil {

     

       824
       -
       		log.Println("failed to create hidden ref:", err, resp.StatusCode)

     

       825
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       826
       -
       		return

     

       827
       -
       	}

     

       828
       -
       

     

       829
       -
       	switch resp.StatusCode {

     

       830
       -
       	case 404:

     

       831
       -
       	case 400:

     

       832
       -
       		s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")

     

       833
       -
       		return

     

       834
       -
       	}

     

       835
       -
       

     

       836
       -
       	hiddenRef := fmt.Sprintf("hidden/%s/%s", sourceBranch, targetBranch)

     

       837
       -
       	// We're now comparing the sourceBranch (on the fork) against the hiddenRef which is tracking

     

       838
       -
       	// the targetBranch on the target repository. This code is a bit confusing, but here's an example:

     

       839
       -
       	// hiddenRef: hidden/feature-1/main (on repo-fork)

     

       840
       -
       	// targetBranch: main (on repo-1)

     

       841
       -
       	// sourceBranch: feature-1 (on repo-fork)

     

       842
       -
       	comparison, err := us.Compare(user.Did, fork.Name, hiddenRef, sourceBranch)

     

       843
       -
       	if err != nil {

     

       844
       -
       		log.Println("failed to compare across branches", err)

     

       845
       -
       		s.pages.Notice(w, "pull", err.Error())

     

       846
       -
       		return

     

       847
       -
       	}

     

       848
       -
       

     

       849
       -
       	sourceRev := comparison.Rev2

     

       850
       -
       	patch := comparison.Patch

     

       851
       -
       

     

       852
       -
       	if !patchutil.IsPatchValid(patch) {

     

       853
       -
       		s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.")

     

       854
       -
       		return

     

       855
       -
       	}

     

       856
       -
       

     

       857
       -
       	forkAtUri, err := syntax.ParseATURI(fork.AtUri)

     

       858
       -
       	if err != nil {

     

       859
       -
       		log.Println("failed to parse fork AT URI", err)

     

       860
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       861
       -
       		return

     

       862
       -
       	}

     

       863
       -
       

     

       864
       -
       	s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, &db.PullSource{

     

       865
       -
       		Branch: sourceBranch,

     

       866
       -
       		RepoAt: &forkAtUri,

     

       867
       -
       	}, &tangled.RepoPull_Source{Branch: sourceBranch, Repo: &fork.AtUri}, isStacked)

     

       868
       -
       }

     

       869
       -
       

     

       870
       -
       func (s *State) createPullRequest(

     

       871
       -
       	w http.ResponseWriter,

     

       872
       -
       	r *http.Request,

     

       873
       -
       	f *reporesolver.ResolvedRepo,

     

       874
       -
       	user *oauth.User,

     

       875
       -
       	title, body, targetBranch string,

     

       876
       -
       	patch string,

     

       877
       -
       	sourceRev string,

     

       878
       -
       	pullSource *db.PullSource,

     

       879
       -
       	recordPullSource *tangled.RepoPull_Source,

     

       880
       -
       	isStacked bool,

     

       881
       -
       ) {

     

       882
       -
       	if isStacked {

     

       883
       -
       		// creates a series of PRs, each linking to the previous, identified by jj's change-id

     

       884
       -
       		s.createStackedPulLRequest(

     

       885
       -
       			w,

     

       886
       -
       			r,

     

       887
       -
       			f,

     

       888
       -
       			user,

     

       889
       -
       			targetBranch,

     

       890
       -
       			patch,

     

       891
       -
       			sourceRev,

     

       892
       -
       			pullSource,

     

       893
       -
       		)

     

       894
       -
       		return

     

       895
       -
       	}

     

       896
       -
       

     

       897
       -
       	client, err := s.oauth.AuthorizedClient(r)

     

       898
       -
       	if err != nil {

     

       899
       -
       		log.Println("failed to get authorized client", err)

     

       900
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       901
       -
       		return

     

       902
       -
       	}

     

       903
       -
       

     

       904
       -
       	tx, err := s.db.BeginTx(r.Context(), nil)

     

       905
       -
       	if err != nil {

     

       906
       -
       		log.Println("failed to start tx")

     

       907
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       908
       -
       		return

     

       909
       -
       	}

     

       910
       -
       	defer tx.Rollback()

     

       911
       -
       

     

       912
       -
       	// We've already checked earlier if it's diff-based and title is empty,

     

       913
       -
       	// so if it's still empty now, it's intentionally skipped owing to format-patch.

     

       914
       -
       	if title == "" {

     

       915
       -
       		formatPatches, err := patchutil.ExtractPatches(patch)

     

       916
       -
       		if err != nil {

     

       917
       -
       			s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))

     

       918
       -
       			return

     

       919
       -
       		}

     

       920
       -
       		if len(formatPatches) == 0 {

     

       921
       -
       			s.pages.Notice(w, "pull", "No patches found in the supplied format-patch.")

     

       922
       -
       			return

     

       923
       -
       		}

     

       924
       -
       

     

       925
       -
       		title = formatPatches[0].Title

     

       926
       -
       		body = formatPatches[0].Body

     

       927
       -
       	}

     

       928
       -
       

     

       929
       -
       	rkey := appview.TID()

     

       930
       -
       	initialSubmission := db.PullSubmission{

     

       931
       -
       		Patch:     patch,

     

       932
       -
       		SourceRev: sourceRev,

     

       933
       -
       	}

     

       934
       -
       	err = db.NewPull(tx, &db.Pull{

     

       935
       -
       		Title:        title,

     

       936
       -
       		Body:         body,

     

       937
       -
       		TargetBranch: targetBranch,

     

       938
       -
       		OwnerDid:     user.Did,

     

       939
       -
       		RepoAt:       f.RepoAt,

     

       940
       -
       		Rkey:         rkey,

     

       941
       -
       		Submissions: []*db.PullSubmission{

     

       942
       -
       			&initialSubmission,

     

       943
       -
       		},

     

       944
       -
       		PullSource: pullSource,

     

       945
       -
       	})

     

       946
       -
       	if err != nil {

     

       947
       -
       		log.Println("failed to create pull request", err)

     

       948
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       949
       -
       		return

     

       950
       -
       	}

     

       951
       -
       	pullId, err := db.NextPullId(tx, f.RepoAt)

     

       952
       -
       	if err != nil {

     

       953
       -
       		log.Println("failed to get pull id", err)

     

       954
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       955
       -
       		return

     

       956
       -
       	}

     

       957
       -
       

     

       958
       -
       	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       959
       -
       		Collection: tangled.RepoPullNSID,

     

       960
       -
       		Repo:       user.Did,

     

       961
       -
       		Rkey:       rkey,

     

       962
       -
       		Record: &lexutil.LexiconTypeDecoder{

     

       963
       -
       			Val: &tangled.RepoPull{

     

       964
       -
       				Title:        title,

     

       965
       -
       				PullId:       int64(pullId),

     

       966
       -
       				TargetRepo:   string(f.RepoAt),

     

       967
       -
       				TargetBranch: targetBranch,

     

       968
       -
       				Patch:        patch,

     

       969
       -
       				Source:       recordPullSource,

     

       970
       -
       			},

     

       971
       -
       		},

     

       972
       -
       	})

     

       973
       -
       	if err != nil {

     

       974
       -
       		log.Println("failed to create pull request", err)

     

       975
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       976
       -
       		return

     

       977
       -
       	}

     

       978
       -
       

     

       979
       -
       	if err = tx.Commit(); err != nil {

     

       980
       -
       		log.Println("failed to create pull request", err)

     

       981
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       982
       -
       		return

     

       983
       -
       	}

     

       984
       -
       

     

       985
       -
       	if !s.config.Core.Dev {

     

       986
       -
       		err = s.posthog.Enqueue(posthog.Capture{

     

       987
       -
       			DistinctId: user.Did,

     

       988
       -
       			Event:      "new_pull",

     

       989
       -
       			Properties: posthog.Properties{"repo_at": f.RepoAt.String(), "pull_id": pullId},

     

       990
       -
       		})

     

       991
       -
       		if err != nil {

     

       992
       -
       			log.Println("failed to enqueue posthog event:", err)

     

       993
       -
       		}

     

       994
       -
       	}

     

       995
       -
       

     

       996
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId))

     

       997
       -
       }

     

       998
       -
       

     

       999
       -
       func (s *State) createStackedPulLRequest(

     

       1000
       -
       	w http.ResponseWriter,

     

       1001
       -
       	r *http.Request,

     

       1002
       -
       	f *reporesolver.ResolvedRepo,

     

       1003
       -
       	user *oauth.User,

     

       1004
       -
       	targetBranch string,

     

       1005
       -
       	patch string,

     

       1006
       -
       	sourceRev string,

     

       1007
       -
       	pullSource *db.PullSource,

     

       1008
       -
       ) {

     

       1009
       -
       	// run some necessary checks for stacked-prs first

     

       1010
       -
       

     

       1011
       -
       	//  must be branch or fork based

     

       1012
       -
       	if sourceRev == "" {

     

       1013
       -
       		log.Println("stacked PR from patch-based pull")

     

       1014
       -
       		s.pages.Notice(w, "pull", "Stacking is only supported on branch and fork based pull-requests.")

     

       1015
       -
       		return

     

       1016
       -
       	}

     

       1017
       -
       

     

       1018
       -
       	formatPatches, err := patchutil.ExtractPatches(patch)

     

       1019
       -
       	if err != nil {

     

       1020
       -
       		log.Println("failed to extract patches", err)

     

       1021
       -
       		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))

     

       1022
       -
       		return

     

       1023
       -
       	}

     

       1024
       -
       

     

       1025
       -
       	//  must have atleast 1 patch to begin with

     

       1026
       -
       	if len(formatPatches) == 0 {

     

       1027
       -
       		log.Println("empty patches")

     

       1028
       -
       		s.pages.Notice(w, "pull", "No patches found in the generated format-patch.")

     

       1029
       -
       		return

     

       1030
       -
       	}

     

       1031
       -
       

     

       1032
       -
       	// build a stack out of this patch

     

       1033
       -
       	stackId := uuid.New()

     

       1034
       -
       	stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String())

     

       1035
       -
       	if err != nil {

     

       1036
       -
       		log.Println("failed to create stack", err)

     

       1037
       -
       		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))

     

       1038
       -
       		return

     

       1039
       -
       	}

     

       1040
       -
       

     

       1041
       -
       	client, err := s.oauth.AuthorizedClient(r)

     

       1042
       -
       	if err != nil {

     

       1043
       -
       		log.Println("failed to get authorized client", err)

     

       1044
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1045
       -
       		return

     

       1046
       -
       	}

     

       1047
       -
       

     

       1048
       -
       	// apply all record creations at once

     

       1049
       -
       	var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem

     

       1050
       -
       	for _, p := range stack {

     

       1051
       -
       		record := p.AsRecord()

     

       1052
       -
       		write := comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1053
       -
       			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{

     

       1054
       -
       				Collection: tangled.RepoPullNSID,

     

       1055
       -
       				Rkey:       &p.Rkey,

     

       1056
       -
       				Value: &lexutil.LexiconTypeDecoder{

     

       1057
       -
       					Val: &record,

     

       1058
       -
       				},

     

       1059
       -
       			},

     

       1060
       -
       		}

     

       1061
       -
       		writes = append(writes, &write)

     

       1062
       -
       	}

     

       1063
       -
       	_, err = client.RepoApplyWrites(r.Context(), &comatproto.RepoApplyWrites_Input{

     

       1064
       -
       		Repo:   user.Did,

     

       1065
       -
       		Writes: writes,

     

       1066
       -
       	})

     

       1067
       -
       	if err != nil {

     

       1068
       -
       		log.Println("failed to create stacked pull request", err)

     

       1069
       -
       		s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")

     

       1070
       -
       		return

     

       1071
       -
       	}

     

       1072
       -
       

     

       1073
       -
       	// create all pulls at once

     

       1074
       -
       	tx, err := s.db.BeginTx(r.Context(), nil)

     

       1075
       -
       	if err != nil {

     

       1076
       -
       		log.Println("failed to start tx")

     

       1077
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1078
       -
       		return

     

       1079
       -
       	}

     

       1080
       -
       	defer tx.Rollback()

     

       1081
       -
       

     

       1082
       -
       	for _, p := range stack {

     

       1083
       -
       		err = db.NewPull(tx, p)

     

       1084
       -
       		if err != nil {

     

       1085
       -
       			log.Println("failed to create pull request", err)

     

       1086
       -
       			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1087
       -
       			return

     

       1088
       -
       		}

     

       1089
       -
       	}

     

       1090
       -
       

     

       1091
       -
       	if err = tx.Commit(); err != nil {

     

       1092
       -
       		log.Println("failed to create pull request", err)

     

       1093
       -
       		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       1094
       -
       		return

     

       1095
       -
       	}

     

       1096
       -
       

     

       1097
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", f.OwnerSlashRepo()))

     

       1098
       -
       }

     

       1099
       -
       

     

       1100
       -
       func (s *State) ValidatePatch(w http.ResponseWriter, r *http.Request) {

     

       1101
       -
       	_, err := s.repoResolver.Resolve(r)

     

       1102
       -
       	if err != nil {

     

       1103
       -
       		log.Println("failed to get repo and knot", err)

     

       1104
       -
       		return

     

       1105
       -
       	}

     

       1106
       -
       

     

       1107
       -
       	patch := r.FormValue("patch")

     

       1108
       -
       	if patch == "" {

     

       1109
       -
       		s.pages.Notice(w, "patch-error", "Patch is required.")

     

       1110
       -
       		return

     

       1111
       -
       	}

     

       1112
       -
       

     

       1113
       -
       	if patch == "" || !patchutil.IsPatchValid(patch) {

     

       1114
       -
       		s.pages.Notice(w, "patch-error", "Invalid patch format. Please provide a valid git diff or format-patch.")

     

       1115
       -
       		return

     

       1116
       -
       	}

     

       1117
       -
       

     

       1118
       -
       	if patchutil.IsFormatPatch(patch) {

     

       1119
       -
       		s.pages.Notice(w, "patch-preview", "git-format-patch detected. Title and description are optional; if left out, they will be extracted from the first commit.")

     

       1120
       -
       	} else {

     

       1121
       -
       		s.pages.Notice(w, "patch-preview", "Regular git-diff detected. Please provide a title and description.")

     

       1122
       -
       	}

     

       1123
       -
       }

     

       1124
       -
       

     

       1125
       -
       func (s *State) PatchUploadFragment(w http.ResponseWriter, r *http.Request) {

     

       1126
       -
       	user := s.oauth.GetUser(r)

     

       1127
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1128
       -
       	if err != nil {

     

       1129
       -
       		log.Println("failed to get repo and knot", err)

     

       1130
       -
       		return

     

       1131
       -
       	}

     

       1132
       -
       

     

       1133
       -
       	s.pages.PullPatchUploadFragment(w, pages.PullPatchUploadParams{

     

       1134
       -
       		RepoInfo: f.RepoInfo(user),

     

       1135
       -
       	})

     

       1136
       -
       }

     

       1137
       -
       

     

       1138
       -
       func (s *State) CompareBranchesFragment(w http.ResponseWriter, r *http.Request) {

     

       1139
       -
       	user := s.oauth.GetUser(r)

     

       1140
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1141
       -
       	if err != nil {

     

       1142
       -
       		log.Println("failed to get repo and knot", err)

     

       1143
       -
       		return

     

       1144
       -
       	}

     

       1145
       -
       

     

       1146
       -
       	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1147
       -
       	if err != nil {

     

       1148
       -
       		log.Printf("failed to create unsigned client for %s", f.Knot)

     

       1149
       -
       		s.pages.Error503(w)

     

       1150
       -
       		return

     

       1151
       -
       	}

     

       1152
       -
       

     

       1153
       -
       	result, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       1154
       -
       	if err != nil {

     

       1155
       -
       		log.Println("failed to reach knotserver", err)

     

       1156
       -
       		return

     

       1157
       -
       	}

     

       1158
       -
       

     

       1159
       -
       	branches := result.Branches

     

       1160
       -
       	sort.Slice(branches, func(i int, j int) bool {

     

       1161
       -
       		return branches[i].Commit.Committer.When.After(branches[j].Commit.Committer.When)

     

       1162
       -
       	})

     

       1163
       -
       

     

       1164
       -
       	withoutDefault := []types.Branch{}

     

       1165
       -
       	for _, b := range branches {

     

       1166
       -
       		if b.IsDefault {

     

       1167
       -
       			continue

     

       1168
       -
       		}

     

       1169
       -
       		withoutDefault = append(withoutDefault, b)

     

       1170
       -
       	}

     

       1171
       -
       

     

       1172
       -
       	s.pages.PullCompareBranchesFragment(w, pages.PullCompareBranchesParams{

     

       1173
       -
       		RepoInfo: f.RepoInfo(user),

     

       1174
       -
       		Branches: withoutDefault,

     

       1175
       -
       	})

     

       1176
       -
       }

     

       1177
       -
       

     

       1178
       -
       func (s *State) CompareForksFragment(w http.ResponseWriter, r *http.Request) {

     

       1179
       -
       	user := s.oauth.GetUser(r)

     

       1180
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1181
       -
       	if err != nil {

     

       1182
       -
       		log.Println("failed to get repo and knot", err)

     

       1183
       -
       		return

     

       1184
       -
       	}

     

       1185
       -
       

     

       1186
       -
       	forks, err := db.GetForksByDid(s.db, user.Did)

     

       1187
       -
       	if err != nil {

     

       1188
       -
       		log.Println("failed to get forks", err)

     

       1189
       -
       		return

     

       1190
       -
       	}

     

       1191
       -
       

     

       1192
       -
       	s.pages.PullCompareForkFragment(w, pages.PullCompareForkParams{

     

       1193
       -
       		RepoInfo: f.RepoInfo(user),

     

       1194
       -
       		Forks:    forks,

     

       1195
       -
       		Selected: r.URL.Query().Get("fork"),

     

       1196
       -
       	})

     

       1197
       -
       }

     

       1198
       -
       

     

       1199
       -
       func (s *State) CompareForksBranchesFragment(w http.ResponseWriter, r *http.Request) {

     

       1200
       -
       	user := s.oauth.GetUser(r)

     

       1201
       -
       

     

       1202
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1203
       -
       	if err != nil {

     

       1204
       -
       		log.Println("failed to get repo and knot", err)

     

       1205
       -
       		return

     

       1206
       -
       	}

     

       1207
       -
       

     

       1208
       -
       	forkVal := r.URL.Query().Get("fork")

     

       1209
       -
       

     

       1210
       -
       	// fork repo

     

       1211
       -
       	repo, err := db.GetRepo(s.db, user.Did, forkVal)

     

       1212
       -
       	if err != nil {

     

       1213
       -
       		log.Println("failed to get repo", user.Did, forkVal)

     

       1214
       -
       		return

     

       1215
       -
       	}

     

       1216
       -
       

     

       1217
       -
       	sourceBranchesClient, err := knotclient.NewUnsignedClient(repo.Knot, s.config.Core.Dev)

     

       1218
       -
       	if err != nil {

     

       1219
       -
       		log.Printf("failed to create unsigned client for %s", repo.Knot)

     

       1220
       -
       		s.pages.Error503(w)

     

       1221
       -
       		return

     

       1222
       -
       	}

     

       1223
       -
       

     

       1224
       -
       	sourceResult, err := sourceBranchesClient.Branches(user.Did, repo.Name)

     

       1225
       -
       	if err != nil {

     

       1226
       -
       		log.Println("failed to reach knotserver for source branches", err)

     

       1227
       -
       		return

     

       1228
       -
       	}

     

       1229
       -
       

     

       1230
       -
       	targetBranchesClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1231
       -
       	if err != nil {

     

       1232
       -
       		log.Printf("failed to create unsigned client for target knot %s", f.Knot)

     

       1233
       -
       		s.pages.Error503(w)

     

       1234
       -
       		return

     

       1235
       -
       	}

     

       1236
       -
       

     

       1237
       -
       	targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)

     

       1238
       -
       	if err != nil {

     

       1239
       -
       		log.Println("failed to reach knotserver for target branches", err)

     

       1240
       -
       		return

     

       1241
       -
       	}

     

       1242
       -
       

     

       1243
       -
       	sourceBranches := sourceResult.Branches

     

       1244
       -
       	sort.Slice(sourceBranches, func(i int, j int) bool {

     

       1245
       -
       		return sourceBranches[i].Commit.Committer.When.After(sourceBranches[j].Commit.Committer.When)

     

       1246
       -
       	})

     

       1247
       -
       

     

       1248
       -
       	s.pages.PullCompareForkBranchesFragment(w, pages.PullCompareForkBranchesParams{

     

       1249
       -
       		RepoInfo:       f.RepoInfo(user),

     

       1250
       -
       		SourceBranches: sourceBranches,

     

       1251
       -
       		TargetBranches: targetResult.Branches,

     

       1252
       -
       	})

     

       1253
       -
       }

     

       1254
       -
       

     

       1255
       -
       func (s *State) ResubmitPull(w http.ResponseWriter, r *http.Request) {

     

       1256
       -
       	user := s.oauth.GetUser(r)

     

       1257
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1258
       -
       	if err != nil {

     

       1259
       -
       		log.Println("failed to get repo and knot", err)

     

       1260
       -
       		return

     

       1261
       -
       	}

     

       1262
       -
       

     

       1263
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1264
       -
       	if !ok {

     

       1265
       -
       		log.Println("failed to get pull")

     

       1266
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       1267
       -
       		return

     

       1268
       -
       	}

     

       1269
       -
       

     

       1270
       -
       	switch r.Method {

     

       1271
       -
       	case http.MethodGet:

     

       1272
       -
       		s.pages.PullResubmitFragment(w, pages.PullResubmitParams{

     

       1273
       -
       			RepoInfo: f.RepoInfo(user),

     

       1274
       -
       			Pull:     pull,

     

       1275
       -
       		})

     

       1276
       -
       		return

     

       1277
       -
       	case http.MethodPost:

     

       1278
       -
       		if pull.IsPatchBased() {

     

       1279
       -
       			s.resubmitPatch(w, r)

     

       1280
       -
       			return

     

       1281
       -
       		} else if pull.IsBranchBased() {

     

       1282
       -
       			s.resubmitBranch(w, r)

     

       1283
       -
       			return

     

       1284
       -
       		} else if pull.IsForkBased() {

     

       1285
       -
       			s.resubmitFork(w, r)

     

       1286
       -
       			return

     

       1287
       -
       		}

     

       1288
       -
       	}

     

       1289
       -
       }

     

       1290
       -
       

     

       1291
       -
       func (s *State) resubmitPatch(w http.ResponseWriter, r *http.Request) {

     

       1292
       -
       	user := s.oauth.GetUser(r)

     

       1293
       -
       

     

       1294
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1295
       -
       	if !ok {

     

       1296
       -
       		log.Println("failed to get pull")

     

       1297
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       1298
       -
       		return

     

       1299
       -
       	}

     

       1300
       -
       

     

       1301
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1302
       -
       	if err != nil {

     

       1303
       -
       		log.Println("failed to get repo and knot", err)

     

       1304
       -
       		return

     

       1305
       -
       	}

     

       1306
       -
       

     

       1307
       -
       	if user.Did != pull.OwnerDid {

     

       1308
       -
       		log.Println("unauthorized user")

     

       1309
       -
       		w.WriteHeader(http.StatusUnauthorized)

     

       1310
       -
       		return

     

       1311
       -
       	}

     

       1312
       -
       

     

       1313
       -
       	patch := r.FormValue("patch")

     

       1314
       -
       

     

       1315
       -
       	s.resubmitPullHelper(w, r, f, user, pull, patch, "")

     

       1316
       -
       }

     

       1317
       -
       

     

       1318
       -
       func (s *State) resubmitBranch(w http.ResponseWriter, r *http.Request) {

     

       1319
       -
       	user := s.oauth.GetUser(r)

     

       1320
       -
       

     

       1321
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1322
       -
       	if !ok {

     

       1323
       -
       		log.Println("failed to get pull")

     

       1324
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")

     

       1325
       -
       		return

     

       1326
       -
       	}

     

       1327
       -
       

     

       1328
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1329
       -
       	if err != nil {

     

       1330
       -
       		log.Println("failed to get repo and knot", err)

     

       1331
       -
       		return

     

       1332
       -
       	}

     

       1333
       -
       

     

       1334
       -
       	if user.Did != pull.OwnerDid {

     

       1335
       -
       		log.Println("unauthorized user")

     

       1336
       -
       		w.WriteHeader(http.StatusUnauthorized)

     

       1337
       -
       		return

     

       1338
       -
       	}

     

       1339
       -
       

     

       1340
       -
       	if !f.RepoInfo(user).Roles.IsPushAllowed() {

     

       1341
       -
       		log.Println("unauthorized user")

     

       1342
       -
       		w.WriteHeader(http.StatusUnauthorized)

     

       1343
       -
       		return

     

       1344
       -
       	}

     

       1345
       -
       

     

       1346
       -
       	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)

     

       1347
       -
       	if err != nil {

     

       1348
       -
       		log.Printf("failed to create client for %s: %s", f.Knot, err)

     

       1349
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1350
       -
       		return

     

       1351
       -
       	}

     

       1352
       -
       

     

       1353
       -
       	comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch)

     

       1354
       -
       	if err != nil {

     

       1355
       -
       		log.Printf("compare request failed: %s", err)

     

       1356
       -
       		s.pages.Notice(w, "resubmit-error", err.Error())

     

       1357
       -
       		return

     

       1358
       -
       	}

     

       1359
       -
       

     

       1360
       -
       	sourceRev := comparison.Rev2

     

       1361
       -
       	patch := comparison.Patch

     

       1362
       -
       

     

       1363
       -
       	s.resubmitPullHelper(w, r, f, user, pull, patch, sourceRev)

     

       1364
       -
       }

     

       1365
       -
       

     

       1366
       -
       func (s *State) resubmitFork(w http.ResponseWriter, r *http.Request) {

     

       1367
       -
       	user := s.oauth.GetUser(r)

     

       1368
       -
       

     

       1369
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1370
       -
       	if !ok {

     

       1371
       -
       		log.Println("failed to get pull")

     

       1372
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")

     

       1373
       -
       		return

     

       1374
       -
       	}

     

       1375
       -
       

     

       1376
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1377
       -
       	if err != nil {

     

       1378
       -
       		log.Println("failed to get repo and knot", err)

     

       1379
       -
       		return

     

       1380
       -
       	}

     

       1381
       -
       

     

       1382
       -
       	if user.Did != pull.OwnerDid {

     

       1383
       -
       		log.Println("unauthorized user")

     

       1384
       -
       		w.WriteHeader(http.StatusUnauthorized)

     

       1385
       -
       		return

     

       1386
       -
       	}

     

       1387
       -
       

     

       1388
       -
       	forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())

     

       1389
       -
       	if err != nil {

     

       1390
       -
       		log.Println("failed to get source repo", err)

     

       1391
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1392
       -
       		return

     

       1393
       -
       	}

     

       1394
       -
       

     

       1395
       -
       	// extract patch by performing compare

     

       1396
       -
       	ksClient, err := knotclient.NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)

     

       1397
       -
       	if err != nil {

     

       1398
       -
       		log.Printf("failed to create client for %s: %s", forkRepo.Knot, err)

     

       1399
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1400
       -
       		return

     

       1401
       -
       	}

     

       1402
       -
       

     

       1403
       -
       	secret, err := db.GetRegistrationKey(s.db, forkRepo.Knot)

     

       1404
       -
       	if err != nil {

     

       1405
       -
       		log.Printf("failed to get registration key for %s: %s", forkRepo.Knot, err)

     

       1406
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1407
       -
       		return

     

       1408
       -
       	}

     

       1409
       -
       

     

       1410
       -
       	// update the hidden tracking branch to latest

     

       1411
       -
       	signedClient, err := knotclient.NewSignedClient(forkRepo.Knot, secret, s.config.Core.Dev)

     

       1412
       -
       	if err != nil {

     

       1413
       -
       		log.Printf("failed to create signed client for %s: %s", forkRepo.Knot, err)

     

       1414
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1415
       -
       		return

     

       1416
       -
       	}

     

       1417
       -
       

     

       1418
       -
       	resp, err := signedClient.NewHiddenRef(forkRepo.Did, forkRepo.Name, pull.PullSource.Branch, pull.TargetBranch)

     

       1419
       -
       	if err != nil || resp.StatusCode != http.StatusNoContent {

     

       1420
       -
       		log.Printf("failed to update tracking branch: %s", err)

     

       1421
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1422
       -
       		return

     

       1423
       -
       	}

     

       1424
       -
       

     

       1425
       -
       	hiddenRef := fmt.Sprintf("hidden/%s/%s", pull.PullSource.Branch, pull.TargetBranch)

     

       1426
       -
       	comparison, err := ksClient.Compare(forkRepo.Did, forkRepo.Name, hiddenRef, pull.PullSource.Branch)

     

       1427
       -
       	if err != nil {

     

       1428
       -
       		log.Printf("failed to compare branches: %s", err)

     

       1429
       -
       		s.pages.Notice(w, "resubmit-error", err.Error())

     

       1430
       -
       		return

     

       1431
       -
       	}

     

       1432
       -
       

     

       1433
       -
       	sourceRev := comparison.Rev2

     

       1434
       -
       	patch := comparison.Patch

     

       1435
       -
       

     

       1436
       -
       	s.resubmitPullHelper(w, r, f, user, pull, patch, sourceRev)

     

       1437
       -
       }

     

       1438
       -
       

     

       1439
       -
       // validate a resubmission against a pull request

     

       1440
       -
       func validateResubmittedPatch(pull *db.Pull, patch string) error {

     

       1441
       -
       	if patch == "" {

     

       1442
       -
       		return fmt.Errorf("Patch is empty.")

     

       1443
       -
       	}

     

       1444
       -
       

     

       1445
       -
       	if patch == pull.LatestPatch() {

     

       1446
       -
       		return fmt.Errorf("Patch is identical to previous submission.")

     

       1447
       -
       	}

     

       1448
       -
       

     

       1449
       -
       	if !patchutil.IsPatchValid(patch) {

     

       1450
       -
       		return fmt.Errorf("Invalid patch format. Please provide a valid diff.")

     

       1451
       -
       	}

     

       1452
       -
       

     

       1453
       -
       	return nil

     

       1454
       -
       }

     

       1455
       -
       

     

       1456
       -
       func (s *State) resubmitPullHelper(

     

       1457
       -
       	w http.ResponseWriter,

     

       1458
       -
       	r *http.Request,

     

       1459
       -
       	f *reporesolver.ResolvedRepo,

     

       1460
       -
       	user *oauth.User,

     

       1461
       -
       	pull *db.Pull,

     

       1462
       -
       	patch string,

     

       1463
       -
       	sourceRev string,

     

       1464
       -
       ) {

     

       1465
       -
       	if pull.IsStacked() {

     

       1466
       -
       		log.Println("resubmitting stacked PR")

     

       1467
       -
       		s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId)

     

       1468
       -
       		return

     

       1469
       -
       	}

     

       1470
       -
       

     

       1471
       -
       	if err := validateResubmittedPatch(pull, patch); err != nil {

     

       1472
       -
       		s.pages.Notice(w, "resubmit-error", err.Error())

     

       1473
       -
       		return

     

       1474
       -
       	}

     

       1475
       -
       

     

       1476
       -
       	// validate sourceRev if branch/fork based

     

       1477
       -
       	if pull.IsBranchBased() || pull.IsForkBased() {

     

       1478
       -
       		if sourceRev == pull.Submissions[pull.LastRoundNumber()].SourceRev {

     

       1479
       -
       			s.pages.Notice(w, "resubmit-error", "This branch has not changed since the last submission.")

     

       1480
       -
       			return

     

       1481
       -
       		}

     

       1482
       -
       	}

     

       1483
       -
       

     

       1484
       -
       	tx, err := s.db.BeginTx(r.Context(), nil)

     

       1485
       -
       	if err != nil {

     

       1486
       -
       		log.Println("failed to start tx")

     

       1487
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1488
       -
       		return

     

       1489
       -
       	}

     

       1490
       -
       	defer tx.Rollback()

     

       1491
       -
       

     

       1492
       -
       	err = db.ResubmitPull(tx, pull, patch, sourceRev)

     

       1493
       -
       	if err != nil {

     

       1494
       -
       		log.Println("failed to create pull request", err)

     

       1495
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1496
       -
       		return

     

       1497
       -
       	}

     

       1498
       -
       	client, err := s.oauth.AuthorizedClient(r)

     

       1499
       -
       	if err != nil {

     

       1500
       -
       		log.Println("failed to authorize client")

     

       1501
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1502
       -
       		return

     

       1503
       -
       	}

     

       1504
       -
       

     

       1505
       -
       	ex, err := client.RepoGetRecord(r.Context(), "", tangled.RepoPullNSID, user.Did, pull.Rkey)

     

       1506
       -
       	if err != nil {

     

       1507
       -
       		// failed to get record

     

       1508
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to update pull, no record found on PDS.")

     

       1509
       -
       		return

     

       1510
       -
       	}

     

       1511
       -
       

     

       1512
       -
       	var recordPullSource *tangled.RepoPull_Source

     

       1513
       -
       	if pull.IsBranchBased() {

     

       1514
       -
       		recordPullSource = &tangled.RepoPull_Source{

     

       1515
       -
       			Branch: pull.PullSource.Branch,

     

       1516
       -
       		}

     

       1517
       -
       	}

     

       1518
       -
       	if pull.IsForkBased() {

     

       1519
       -
       		repoAt := pull.PullSource.RepoAt.String()

     

       1520
       -
       		recordPullSource = &tangled.RepoPull_Source{

     

       1521
       -
       			Branch: pull.PullSource.Branch,

     

       1522
       -
       			Repo:   &repoAt,

     

       1523
       -
       		}

     

       1524
       -
       	}

     

       1525
       -
       

     

       1526
       -
       	_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       1527
       -
       		Collection: tangled.RepoPullNSID,

     

       1528
       -
       		Repo:       user.Did,

     

       1529
       -
       		Rkey:       pull.Rkey,

     

       1530
       -
       		SwapRecord: ex.Cid,

     

       1531
       -
       		Record: &lexutil.LexiconTypeDecoder{

     

       1532
       -
       			Val: &tangled.RepoPull{

     

       1533
       -
       				Title:        pull.Title,

     

       1534
       -
       				PullId:       int64(pull.PullId),

     

       1535
       -
       				TargetRepo:   string(f.RepoAt),

     

       1536
       -
       				TargetBranch: pull.TargetBranch,

     

       1537
       -
       				Patch:        patch, // new patch

     

       1538
       -
       				Source:       recordPullSource,

     

       1539
       -
       			},

     

       1540
       -
       		},

     

       1541
       -
       	})

     

       1542
       -
       	if err != nil {

     

       1543
       -
       		log.Println("failed to update record", err)

     

       1544
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")

     

       1545
       -
       		return

     

       1546
       -
       	}

     

       1547
       -
       

     

       1548
       -
       	if err = tx.Commit(); err != nil {

     

       1549
       -
       		log.Println("failed to commit transaction", err)

     

       1550
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")

     

       1551
       -
       		return

     

       1552
       -
       	}

     

       1553
       -
       

     

       1554
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       1555
       -
       	return

     

       1556
       -
       }

     

       1557
       -
       

     

       1558
       -
       func (s *State) resubmitStackedPullHelper(

     

       1559
       -
       	w http.ResponseWriter,

     

       1560
       -
       	r *http.Request,

     

       1561
       -
       	f *reporesolver.ResolvedRepo,

     

       1562
       -
       	user *oauth.User,

     

       1563
       -
       	pull *db.Pull,

     

       1564
       -
       	patch string,

     

       1565
       -
       	stackId string,

     

       1566
       -
       ) {

     

       1567
       -
       	targetBranch := pull.TargetBranch

     

       1568
       -
       

     

       1569
       -
       	origStack, _ := r.Context().Value("stack").(db.Stack)

     

       1570
       -
       	newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)

     

       1571
       -
       	if err != nil {

     

       1572
       -
       		log.Println("failed to create resubmitted stack", err)

     

       1573
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1574
       -
       		return

     

       1575
       -
       	}

     

       1576
       -
       

     

       1577
       -
       	// find the diff between the stacks, first, map them by changeId

     

       1578
       -
       	origById := make(map[string]*db.Pull)

     

       1579
       -
       	newById := make(map[string]*db.Pull)

     

       1580
       -
       	for _, p := range origStack {

     

       1581
       -
       		origById[p.ChangeId] = p

     

       1582
       -
       	}

     

       1583
       -
       	for _, p := range newStack {

     

       1584
       -
       		newById[p.ChangeId] = p

     

       1585
       -
       	}

     

       1586
       -
       

     

       1587
       -
       	// commits that got deleted: corresponding pull is closed

     

       1588
       -
       	// commits that got added: new pull is created

     

       1589
       -
       	// commits that got updated: corresponding pull is resubmitted & new round begins

     

       1590
       -
       	//

     

       1591
       -
       	// for commits that were unchanged: no changes, parent-change-id is updated as necessary

     

       1592
       -
       	additions := make(map[string]*db.Pull)

     

       1593
       -
       	deletions := make(map[string]*db.Pull)

     

       1594
       -
       	unchanged := make(map[string]struct{})

     

       1595
       -
       	updated := make(map[string]struct{})

     

       1596
       -
       

     

       1597
       -
       	// pulls in orignal stack but not in new one

     

       1598
       -
       	for _, op := range origStack {

     

       1599
       -
       		if _, ok := newById[op.ChangeId]; !ok {

     

       1600
       -
       			deletions[op.ChangeId] = op

     

       1601
       -
       		}

     

       1602
       -
       	}

     

       1603
       -
       

     

       1604
       -
       	// pulls in new stack but not in original one

     

       1605
       -
       	for _, np := range newStack {

     

       1606
       -
       		if _, ok := origById[np.ChangeId]; !ok {

     

       1607
       -
       			additions[np.ChangeId] = np

     

       1608
       -
       		}

     

       1609
       -
       	}

     

       1610
       -
       

     

       1611
       -
       	// NOTE: this loop can be written in any of above blocks,

     

       1612
       -
       	// but is written separately in the interest of simpler code

     

       1613
       -
       	for _, np := range newStack {

     

       1614
       -
       		if op, ok := origById[np.ChangeId]; ok {

     

       1615
       -
       			// pull exists in both stacks

     

       1616
       -
       			// TODO: can we avoid reparse?

     

       1617
       -
       			origFiles, origHeaderStr, _ := gitdiff.Parse(strings.NewReader(op.LatestPatch()))

     

       1618
       -
       			newFiles, newHeaderStr, _ := gitdiff.Parse(strings.NewReader(np.LatestPatch()))

     

       1619
       -
       

     

       1620
       -
       			origHeader, _ := gitdiff.ParsePatchHeader(origHeaderStr)

     

       1621
       -
       			newHeader, _ := gitdiff.ParsePatchHeader(newHeaderStr)

     

       1622
       -
       

     

       1623
       -
       			patchutil.SortPatch(newFiles)

     

       1624
       -
       			patchutil.SortPatch(origFiles)

     

       1625
       -
       

     

       1626
       -
       			// text content of patch may be identical, but a jj rebase might have forwarded it

     

       1627
       -
       			//

     

       1628
       -
       			// we still need to update the hash in submission.Patch and submission.SourceRev

     

       1629
       -
       			if patchutil.Equal(newFiles, origFiles) &&

     

       1630
       -
       				origHeader.Title == newHeader.Title &&

     

       1631
       -
       				origHeader.Body == newHeader.Body {

     

       1632
       -
       				unchanged[op.ChangeId] = struct{}{}

     

       1633
       -
       			} else {

     

       1634
       -
       				updated[op.ChangeId] = struct{}{}

     

       1635
       -
       			}

     

       1636
       -
       		}

     

       1637
       -
       	}

     

       1638
       -
       

     

       1639
       -
       	tx, err := s.db.Begin()

     

       1640
       -
       	if err != nil {

     

       1641
       -
       		log.Println("failed to start transaction", err)

     

       1642
       -
       		s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1643
       -
       		return

     

       1644
       -
       	}

     

       1645
       -
       	defer tx.Rollback()

     

       1646
       -
       

     

       1647
       -
       	// pds updates to make

     

       1648
       -
       	var writes []*comatproto.RepoApplyWrites_Input_Writes_Elem

     

       1649
       -
       

     

       1650
       -
       	// deleted pulls are marked as deleted in the DB

     

       1651
       -
       	for _, p := range deletions {

     

       1652
       -
       		err := db.DeletePull(tx, p.RepoAt, p.PullId)

     

       1653
       -
       		if err != nil {

     

       1654
       -
       			log.Println("failed to delete pull", err, p.PullId)

     

       1655
       -
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1656
       -
       			return

     

       1657
       -
       		}

     

       1658
       -
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1659
       -
       			RepoApplyWrites_Delete: &comatproto.RepoApplyWrites_Delete{

     

       1660
       -
       				Collection: tangled.RepoPullNSID,

     

       1661
       -
       				Rkey:       p.Rkey,

     

       1662
       -
       			},

     

       1663
       -
       		})

     

       1664
       -
       	}

     

       1665
       -
       

     

       1666
       -
       	// new pulls are created

     

       1667
       -
       	for _, p := range additions {

     

       1668
       -
       		err := db.NewPull(tx, p)

     

       1669
       -
       		if err != nil {

     

       1670
       -
       			log.Println("failed to create pull", err, p.PullId)

     

       1671
       -
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1672
       -
       			return

     

       1673
       -
       		}

     

       1674
       -
       

     

       1675
       -
       		record := p.AsRecord()

     

       1676
       -
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1677
       -
       			RepoApplyWrites_Create: &comatproto.RepoApplyWrites_Create{

     

       1678
       -
       				Collection: tangled.RepoPullNSID,

     

       1679
       -
       				Rkey:       &p.Rkey,

     

       1680
       -
       				Value: &lexutil.LexiconTypeDecoder{

     

       1681
       -
       					Val: &record,

     

       1682
       -
       				},

     

       1683
       -
       			},

     

       1684
       -
       		})

     

       1685
       -
       	}

     

       1686
       -
       

     

       1687
       -
       	// updated pulls are, well, updated; to start a new round

     

       1688
       -
       	for id := range updated {

     

       1689
       -
       		op, _ := origById[id]

     

       1690
       -
       		np, _ := newById[id]

     

       1691
       -
       

     

       1692
       -
       		submission := np.Submissions[np.LastRoundNumber()]

     

       1693
       -
       

     

       1694
       -
       		// resubmit the old pull

     

       1695
       -
       		err := db.ResubmitPull(tx, op, submission.Patch, submission.SourceRev)

     

       1696
       -
       

     

       1697
       -
       		if err != nil {

     

       1698
       -
       			log.Println("failed to update pull", err, op.PullId)

     

       1699
       -
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1700
       -
       			return

     

       1701
       -
       		}

     

       1702
       -
       

     

       1703
       -
       		record := op.AsRecord()

     

       1704
       -
       		record.Patch = submission.Patch

     

       1705
       -
       

     

       1706
       -
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1707
       -
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     

       1708
       -
       				Collection: tangled.RepoPullNSID,

     

       1709
       -
       				Rkey:       op.Rkey,

     

       1710
       -
       				Value: &lexutil.LexiconTypeDecoder{

     

       1711
       -
       					Val: &record,

     

       1712
       -
       				},

     

       1713
       -
       			},

     

       1714
       -
       		})

     

       1715
       -
       	}

     

       1716
       -
       

     

       1717
       -
       	// unchanged pulls are edited without starting a new round

     

       1718
       -
       	//

     

       1719
       -
       	// update source-revs & patches without advancing rounds

     

       1720
       -
       	for changeId := range unchanged {

     

       1721
       -
       		op, _ := origById[changeId]

     

       1722
       -
       		np, _ := newById[changeId]

     

       1723
       -
       

     

       1724
       -
       		origSubmission := op.Submissions[op.LastRoundNumber()]

     

       1725
       -
       		newSubmission := np.Submissions[np.LastRoundNumber()]

     

       1726
       -
       

     

       1727
       -
       		log.Println("moving unchanged change id : ", changeId)

     

       1728
       -
       

     

       1729
       -
       		err := db.UpdatePull(

     

       1730
       -
       			tx,

     

       1731
       -
       			newSubmission.Patch,

     

       1732
       -
       			newSubmission.SourceRev,

     

       1733
       -
       			db.FilterEq("id", origSubmission.ID),

     

       1734
       -
       		)

     

       1735
       -
       

     

       1736
       -
       		if err != nil {

     

       1737
       -
       			log.Println("failed to update pull", err, op.PullId)

     

       1738
       -
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1739
       -
       			return

     

       1740
       -
       		}

     

       1741
       -
       

     

       1742
       -
       		record := op.AsRecord()

     

       1743
       -
       		record.Patch = newSubmission.Patch

     

       1744
       -
       

     

       1745
       -
       		writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{

     

       1746
       -
       			RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{

     

       1747
       -
       				Collection: tangled.RepoPullNSID,

     

       1748
       -
       				Rkey:       op.Rkey,

     

       1749
       -
       				Value: &lexutil.LexiconTypeDecoder{

     

       1750
       -
       					Val: &record,

     

       1751
       -
       				},

     

       1752
       -
       			},

     

       1753
       -
       		})

     

       1754
       -
       	}

     

       1755
       -
       

     

       1756
       -
       	// update parent-change-id relations for the entire stack

     

       1757
       -
       	for _, p := range newStack {

     

       1758
       -
       		err := db.SetPullParentChangeId(

     

       1759
       -
       			tx,

     

       1760
       -
       			p.ParentChangeId,

     

       1761
       -
       			// these should be enough filters to be unique per-stack

     

       1762
       -
       			db.FilterEq("repo_at", p.RepoAt.String()),

     

       1763
       -
       			db.FilterEq("owner_did", p.OwnerDid),

     

       1764
       -
       			db.FilterEq("change_id", p.ChangeId),

     

       1765
       -
       		)

     

       1766
       -
       

     

       1767
       -
       		if err != nil {

     

       1768
       -
       			log.Println("failed to update pull", err, p.PullId)

     

       1769
       -
       			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1770
       -
       			return

     

       1771
       -
       		}

     

       1772
       -
       	}

     

       1773
       -
       

     

       1774
       -
       	err = tx.Commit()

     

       1775
       -
       	if err != nil {

     

       1776
       -
       		log.Println("failed to resubmit pull", err)

     

       1777
       -
       		s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")

     

       1778
       -
       		return

     

       1779
       -
       	}

     

       1780
       -
       

     

       1781
       -
       	client, err := s.oauth.AuthorizedClient(r)

     

       1782
       -
       	if err != nil {

     

       1783
       -
       		log.Println("failed to authorize client")

     

       1784
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1785
       -
       		return

     

       1786
       -
       	}

     

       1787
       -
       

     

       1788
       -
       	_, err = client.RepoApplyWrites(r.Context(), &comatproto.RepoApplyWrites_Input{

     

       1789
       -
       		Repo:   user.Did,

     

       1790
       -
       		Writes: writes,

     

       1791
       -
       	})

     

       1792
       -
       	if err != nil {

     

       1793
       -
       		log.Println("failed to create stacked pull request", err)

     

       1794
       -
       		s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")

     

       1795
       -
       		return

     

       1796
       -
       	}

     

       1797
       -
       

     

       1798
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       1799
       -
       	return

     

       1800
       -
       }

     

       1801
       -
       

     

       1802
       -
       func (s *State) MergePull(w http.ResponseWriter, r *http.Request) {

     

       1803
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1804
       -
       	if err != nil {

     

       1805
       -
       		log.Println("failed to resolve repo:", err)

     

       1806
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1807
       -
       		return

     

       1808
       -
       	}

     

       1809
       -
       

     

       1810
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1811
       -
       	if !ok {

     

       1812
       -
       		log.Println("failed to get pull")

     

       1813
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")

     

       1814
       -
       		return

     

       1815
       -
       	}

     

       1816
       -
       

     

       1817
       -
       	var pullsToMerge db.Stack

     

       1818
       -
       	pullsToMerge = append(pullsToMerge, pull)

     

       1819
       -
       	if pull.IsStacked() {

     

       1820
       -
       		stack, ok := r.Context().Value("stack").(db.Stack)

     

       1821
       -
       		if !ok {

     

       1822
       -
       			log.Println("failed to get stack")

     

       1823
       -
       			s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")

     

       1824
       -
       			return

     

       1825
       -
       		}

     

       1826
       -
       

     

       1827
       -
       		// combine patches of substack

     

       1828
       -
       		subStack := stack.StrictlyBelow(pull)

     

       1829
       -
       		// collect the portion of the stack that is mergeable

     

       1830
       -
       		mergeable := subStack.Mergeable()

     

       1831
       -
       		// add to total patch

     

       1832
       -
       		pullsToMerge = append(pullsToMerge, mergeable...)

     

       1833
       -
       	}

     

       1834
       -
       

     

       1835
       -
       	patch := pullsToMerge.CombinedPatch()

     

       1836
       -
       

     

       1837
       -
       	secret, err := db.GetRegistrationKey(s.db, f.Knot)

     

       1838
       -
       	if err != nil {

     

       1839
       -
       		log.Printf("no registration key found for domain %s: %s\n", f.Knot, err)

     

       1840
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1841
       -
       		return

     

       1842
       -
       	}

     

       1843
       -
       

     

       1844
       -
       	ident, err := s.resolver.ResolveIdent(r.Context(), pull.OwnerDid)

     

       1845
       -
       	if err != nil {

     

       1846
       -
       		log.Printf("resolving identity: %s", err)

     

       1847
       -
       		w.WriteHeader(http.StatusNotFound)

     

       1848
       -
       		return

     

       1849
       -
       	}

     

       1850
       -
       

     

       1851
       -
       	email, err := db.GetPrimaryEmail(s.db, pull.OwnerDid)

     

       1852
       -
       	if err != nil {

     

       1853
       -
       		log.Printf("failed to get primary email: %s", err)

     

       1854
       -
       	}

     

       1855
       -
       

     

       1856
       -
       	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       1857
       -
       	if err != nil {

     

       1858
       -
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       1859
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1860
       -
       		return

     

       1861
       -
       	}

     

       1862
       -
       

     

       1863
       -
       	// Merge the pull request

     

       1864
       -
       	resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)

     

       1865
       -
       	if err != nil {

     

       1866
       -
       		log.Printf("failed to merge pull request: %s", err)

     

       1867
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1868
       -
       		return

     

       1869
       -
       	}

     

       1870
       -
       

     

       1871
       -
       	if resp.StatusCode != http.StatusOK {

     

       1872
       -
       		log.Printf("knotserver returned non-OK status code for merge: %d", resp.StatusCode)

     

       1873
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1874
       -
       		return

     

       1875
       -
       	}

     

       1876
       -
       

     

       1877
       -
       	tx, err := s.db.Begin()

     

       1878
       -
       	if err != nil {

     

       1879
       -
       		log.Println("failed to start transcation", err)

     

       1880
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1881
       -
       		return

     

       1882
       -
       	}

     

       1883
       -
       	defer tx.Rollback()

     

       1884
       -
       

     

       1885
       -
       	for _, p := range pullsToMerge {

     

       1886
       -
       		err := db.MergePull(tx, f.RepoAt, p.PullId)

     

       1887
       -
       		if err != nil {

     

       1888
       -
       			log.Printf("failed to update pull request status in database: %s", err)

     

       1889
       -
       			s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1890
       -
       			return

     

       1891
       -
       		}

     

       1892
       -
       	}

     

       1893
       -
       

     

       1894
       -
       	err = tx.Commit()

     

       1895
       -
       	if err != nil {

     

       1896
       -
       		// TODO: this is unsound, we should also revert the merge from the knotserver here

     

       1897
       -
       		log.Printf("failed to update pull request status in database: %s", err)

     

       1898
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1899
       -
       		return

     

       1900
       -
       	}

     

       1901
       -
       

     

       1902
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.RepoName, pull.PullId))

     

       1903
       -
       }

     

       1904
       -
       

     

       1905
       -
       func (s *State) ClosePull(w http.ResponseWriter, r *http.Request) {

     

       1906
       -
       	user := s.oauth.GetUser(r)

     

       1907
       -
       

     

       1908
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1909
       -
       	if err != nil {

     

       1910
       -
       		log.Println("malformed middleware")

     

       1911
       -
       		return

     

       1912
       -
       	}

     

       1913
       -
       

     

       1914
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1915
       -
       	if !ok {

     

       1916
       -
       		log.Println("failed to get pull")

     

       1917
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       1918
       -
       		return

     

       1919
       -
       	}

     

       1920
       -
       

     

       1921
       -
       	// auth filter: only owner or collaborators can close

     

       1922
       -
       	roles := f.RolesInRepo(user)

     

       1923
       -
       	isCollaborator := roles.IsCollaborator()

     

       1924
       -
       	isPullAuthor := user.Did == pull.OwnerDid

     

       1925
       -
       	isCloseAllowed := isCollaborator || isPullAuthor

     

       1926
       -
       	if !isCloseAllowed {

     

       1927
       -
       		log.Println("failed to close pull")

     

       1928
       -
       		s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")

     

       1929
       -
       		return

     

       1930
       -
       	}

     

       1931
       -
       

     

       1932
       -
       	// Start a transaction

     

       1933
       -
       	tx, err := s.db.BeginTx(r.Context(), nil)

     

       1934
       -
       	if err != nil {

     

       1935
       -
       		log.Println("failed to start transaction", err)

     

       1936
       -
       		s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       1937
       -
       		return

     

       1938
       -
       	}

     

       1939
       -
       	defer tx.Rollback()

     

       1940
       -
       

     

       1941
       -
       	var pullsToClose []*db.Pull

     

       1942
       -
       	pullsToClose = append(pullsToClose, pull)

     

       1943
       -
       

     

       1944
       -
       	// if this PR is stacked, then we want to close all PRs below this one on the stack

     

       1945
       -
       	if pull.IsStacked() {

     

       1946
       -
       		stack := r.Context().Value("stack").(db.Stack)

     

       1947
       -
       		subStack := stack.StrictlyBelow(pull)

     

       1948
       -
       		pullsToClose = append(pullsToClose, subStack...)

     

       1949
       -
       	}

     

       1950
       -
       

     

       1951
       -
       	for _, p := range pullsToClose {

     

       1952
       -
       		// Close the pull in the database

     

       1953
       -
       		err = db.ClosePull(tx, f.RepoAt, p.PullId)

     

       1954
       -
       		if err != nil {

     

       1955
       -
       			log.Println("failed to close pull", err)

     

       1956
       -
       			s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       1957
       -
       			return

     

       1958
       -
       		}

     

       1959
       -
       	}

     

       1960
       -
       

     

       1961
       -
       	// Commit the transaction

     

       1962
       -
       	if err = tx.Commit(); err != nil {

     

       1963
       -
       		log.Println("failed to commit transaction", err)

     

       1964
       -
       		s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       1965
       -
       		return

     

       1966
       -
       	}

     

       1967
       -
       

     

       1968
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       1969
       -
       	return

     

       1970
       -
       }

     

       1971
       -
       

     

       1972
       -
       func (s *State) ReopenPull(w http.ResponseWriter, r *http.Request) {

     

       1973
       -
       	user := s.oauth.GetUser(r)

     

       1974
       -
       

     

       1975
       -
       	f, err := s.repoResolver.Resolve(r)

     

       1976
       -
       	if err != nil {

     

       1977
       -
       		log.Println("failed to resolve repo", err)

     

       1978
       -
       		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")

     

       1979
       -
       		return

     

       1980
       -
       	}

     

       1981
       -
       

     

       1982
       -
       	pull, ok := r.Context().Value("pull").(*db.Pull)

     

       1983
       -
       	if !ok {

     

       1984
       -
       		log.Println("failed to get pull")

     

       1985
       -
       		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")

     

       1986
       -
       		return

     

       1987
       -
       	}

     

       1988
       -
       

     

       1989
       -
       	// auth filter: only owner or collaborators can close

     

       1990
       -
       	roles := f.RolesInRepo(user)

     

       1991
       -
       	isCollaborator := roles.IsCollaborator()

     

       1992
       -
       	isPullAuthor := user.Did == pull.OwnerDid

     

       1993
       -
       	isCloseAllowed := isCollaborator || isPullAuthor

     

       1994
       -
       	if !isCloseAllowed {

     

       1995
       -
       		log.Println("failed to close pull")

     

       1996
       -
       		s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")

     

       1997
       -
       		return

     

       1998
       -
       	}

     

       1999
       -
       

     

       2000
       -
       	// Start a transaction

     

       2001
       -
       	tx, err := s.db.BeginTx(r.Context(), nil)

     

       2002
       -
       	if err != nil {

     

       2003
       -
       		log.Println("failed to start transaction", err)

     

       2004
       -
       		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")

     

       2005
       -
       		return

     

       2006
       -
       	}

     

       2007
       -
       	defer tx.Rollback()

     

       2008
       -
       

     

       2009
       -
       	var pullsToReopen []*db.Pull

     

       2010
       -
       	pullsToReopen = append(pullsToReopen, pull)

     

       2011
       -
       

     

       2012
       -
       	// if this PR is stacked, then we want to reopen all PRs above this one on the stack

     

       2013
       -
       	if pull.IsStacked() {

     

       2014
       -
       		stack := r.Context().Value("stack").(db.Stack)

     

       2015
       -
       		subStack := stack.StrictlyAbove(pull)

     

       2016
       -
       		pullsToReopen = append(pullsToReopen, subStack...)

     

       2017
       -
       	}

     

       2018
       -
       

     

       2019
       -
       	for _, p := range pullsToReopen {

     

       2020
       -
       		// Close the pull in the database

     

       2021
       -
       		err = db.ReopenPull(tx, f.RepoAt, p.PullId)

     

       2022
       -
       		if err != nil {

     

       2023
       -
       			log.Println("failed to close pull", err)

     

       2024
       -
       			s.pages.Notice(w, "pull-close", "Failed to close pull.")

     

       2025
       -
       			return

     

       2026
       -
       		}

     

       2027
       -
       	}

     

       2028
       -
       

     

       2029
       -
       	// Commit the transaction

     

       2030
       -
       	if err = tx.Commit(); err != nil {

     

       2031
       -
       		log.Println("failed to commit transaction", err)

     

       2032
       -
       		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")

     

       2033
       -
       		return

     

       2034
       -
       	}

     

       2035
       -
       

     

       2036
       -
       	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pull.PullId))

     

       2037
       -
       	return

     

       2038
       -
       }

     

       2039
       -
       

     

       2040
       -
       func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *db.PullSource, stackId string) (db.Stack, error) {

     

       2041
       -
       	formatPatches, err := patchutil.ExtractPatches(patch)

     

       2042
       -
       	if err != nil {

     

       2043
       -
       		return nil, fmt.Errorf("Failed to extract patches: %v", err)

     

       2044
       -
       	}

     

       2045
       -
       

     

       2046
       -
       	//  must have atleast 1 patch to begin with

     

       2047
       -
       	if len(formatPatches) == 0 {

     

       2048
       -
       		return nil, fmt.Errorf("No patches found in the generated format-patch.")

     

       2049
       -
       	}

     

       2050
       -
       

     

       2051
       -
       	// the stack is identified by a UUID

     

       2052
       -
       	var stack db.Stack

     

       2053
       -
       	parentChangeId := ""

     

       2054
       -
       	for _, fp := range formatPatches {

     

       2055
       -
       		//  all patches must have a jj change-id

     

       2056
       -
       		changeId, err := fp.ChangeId()

     

       2057
       -
       		if err != nil {

     

       2058
       -
       			return nil, fmt.Errorf("Stacking is only supported if all patches contain a change-id commit header.")

     

       2059
       -
       		}

     

       2060
       -
       

     

       2061
       -
       		title := fp.Title

     

       2062
       -
       		body := fp.Body

     

       2063
       -
       		rkey := appview.TID()

     

       2064
       -
       

     

       2065
       -
       		initialSubmission := db.PullSubmission{

     

       2066
       -
       			Patch:     fp.Raw,

     

       2067
       -
       			SourceRev: fp.SHA,

     

       2068
       -
       		}

     

       2069
       -
       		pull := db.Pull{

     

       2070
       -
       			Title:        title,

     

       2071
       -
       			Body:         body,

     

       2072
       -
       			TargetBranch: targetBranch,

     

       2073
       -
       			OwnerDid:     user.Did,

     

       2074
       -
       			RepoAt:       f.RepoAt,

     

       2075
       -
       			Rkey:         rkey,

     

       2076
       -
       			Submissions: []*db.PullSubmission{

     

       2077
       -
       				&initialSubmission,

     

       2078
       -
       			},

     

       2079
       -
       			PullSource: pullSource,

     

       2080
       -
       			Created:    time.Now(),

     

       2081
       -
       

     

       2082
       -
       			StackId:        stackId,

     

       2083
       -
       			ChangeId:       changeId,

     

       2084
       -
       			ParentChangeId: parentChangeId,

     

       2085
       -
       		}

     

       2086
       -
       

     

       2087
       -
       		stack = append(stack, &pull)

     

       2088
       -
       

     

       2089
       -
       		parentChangeId = changeId

     

       2090
       -
       	}

     

       2091
       -
       

     

       2092
       -
       	return stack, nil

     

       2093
       -
       }

+2 -2

appview/oauth/client/oauth_client.go

···

       1
        
       package client

     

       2
        
       

     

       3
        
       import (

     

       4
       -
       	oauth "github.com/haileyok/atproto-oauth-golang"

     

       5
       -
       	"github.com/haileyok/atproto-oauth-golang/helpers"

     

       6
        
       )

     

       7
        
       

     

       8
        
       type OAuthClient struct {

···

       1
        
       package client

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	oauth "tangled.sh/icyphox.sh/atproto-oauth"

     

       5
       +
       	"tangled.sh/icyphox.sh/atproto-oauth/helpers"

     

       6
        
       )

     

       7
        
       

     

       8
        
       type OAuthClient struct {

+1 -1

appview/state/repo_util.go

···

       67
        
       	for _, v := range emailToDid {

     

       68
        
       		dids = append(dids, v)

     

       69
        
       	}

     

       70
       -
       	resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)

     

       71
        
       

     

       72
        
       	didHandleMap := make(map[string]string)

     

       73
        
       	for _, identity := range resolvedIdents {

···

       67
        
       	for _, v := range emailToDid {

     

       68
        
       		dids = append(dids, v)

     

       69
        
       	}

     

       70
       +
       	resolvedIdents := s.idResolver.ResolveIdents(context.Background(), dids)

     

       71
        
       

     

       72
        
       	didHandleMap := make(map[string]string)

     

       73
        
       	for _, identity := range resolvedIdents {

+1 -1

appview/consts.go appview/oauth/consts.go

···

       1
       -
       package appview

     

       2
        
       

     

       3
        
       const (

     

       4
        
       	SessionName          = "appview-session"

···

       1
       +
       package oauth

     

       2
        
       

     

       3
        
       const (

     

       4
        
       	SessionName          = "appview-session"

-15

cmd/keyfetch/format.go

···

       1
       -
       package main

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"fmt"

     

       5
       -
       )

     

       6
       -
       

     

       7
       -
       func formatKeyData(repoguardPath, gitDir, logPath, endpoint string, data []map[string]interface{}) string {

     

       8
       -
       	var result string

     

       9
       -
       	for _, entry := range data {

     

       10
       -
       		result += fmt.Sprintf(

     

       11
       -
       			`command="%s -base-dir %s -user %s -log-path %s -internal-api %s",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty %s`+"\n",

     

       12
       -
       			repoguardPath, gitDir, entry["did"], logPath, endpoint, entry["key"])

     

       13
       -
       	}

     

       14
       -
       	return result

     

       15
       -
       }

-46

cmd/keyfetch/main.go

···

       1
       -
       // This program must be configured to run as the sshd AuthorizedKeysCommand.

     

       2
       -
       // The format looks something like this:

     

       3
       -
       //   Match User git

     

       4
       -
       //     AuthorizedKeysCommand /keyfetch -internal-api http://localhost:5444 -repoguard-path /home/git/repoguard

     

       5
       -
       //     AuthorizedKeysCommandUser nobody

     

       6
       -
       //

     

       7
       -
       // The command and its parent directories must be owned by root and set to 0755. Hence, the ideal location for this is

     

       8
       -
       // somewhere already owned by root so you don't have to mess with directory perms.

     

       9
       -
       

     

       10
       -
       package main

     

       11
       -
       

     

       12
       -
       import (

     

       13
       -
       	"encoding/json"

     

       14
       -
       	"flag"

     

       15
       -
       	"fmt"

     

       16
       -
       	"io"

     

       17
       -
       	"log"

     

       18
       -
       	"net/http"

     

       19
       -
       )

     

       20
       -
       

     

       21
       -
       func main() {

     

       22
       -
       	endpoint := flag.String("internal-api", "http://localhost:5444", "Internal API endpoint")

     

       23
       -
       	repoguardPath := flag.String("repoguard-path", "/home/git/repoguard", "Path to the repoguard binary")

     

       24
       -
       	gitDir := flag.String("git-dir", "/home/git", "Path to the git directory")

     

       25
       -
       	logPath := flag.String("log-path", "/home/git/log", "Path to log file")

     

       26
       -
       	flag.Parse()

     

       27
       -
       

     

       28
       -
       	resp, err := http.Get(*endpoint + "/keys")

     

       29
       -
       	if err != nil {

     

       30
       -
       		log.Fatalf("error fetching keys: %v", err)

     

       31
       -
       	}

     

       32
       -
       	defer resp.Body.Close()

     

       33
       -
       

     

       34
       -
       	body, err := io.ReadAll(resp.Body)

     

       35
       -
       	if err != nil {

     

       36
       -
       		log.Fatalf("error reading response body: %v", err)

     

       37
       -
       	}

     

       38
       -
       

     

       39
       -
       	var data []map[string]interface{}

     

       40
       -
       	err = json.Unmarshal(body, &data)

     

       41
       -
       	if err != nil {

     

       42
       -
       		log.Fatalf("error unmarshalling response body: %v", err)

     

       43
       -
       	}

     

       44
       -
       

     

       45
       -
       	fmt.Print(formatKeyData(*repoguardPath, *gitDir, *logPath, *endpoint, data))

     

       46
       -
       }

-207

cmd/repoguard/main.go

···

       1
       -
       package main

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"context"

     

       5
       -
       	"flag"

     

       6
       -
       	"fmt"

     

       7
       -
       	"log"

     

       8
       -
       	"net/http"

     

       9
       -
       	"net/url"

     

       10
       -
       	"os"

     

       11
       -
       	"os/exec"

     

       12
       -
       	"strings"

     

       13
       -
       	"time"

     

       14
       -
       

     

       15
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       16
       -
       	"tangled.sh/tangled.sh/core/appview/idresolver"

     

       17
       -
       )

     

       18
       -
       

     

       19
       -
       var (

     

       20
       -
       	logger   *log.Logger

     

       21
       -
       	logFile  *os.File

     

       22
       -
       	clientIP string

     

       23
       -
       

     

       24
       -
       	// Command line flags

     

       25
       -
       	incomingUser = flag.String("user", "", "Allowed git user")

     

       26
       -
       	baseDirFlag  = flag.String("base-dir", "/home/git", "Base directory for git repositories")

     

       27
       -
       	logPathFlag  = flag.String("log-path", "/var/log/git-wrapper.log", "Path to log file")

     

       28
       -
       	endpoint     = flag.String("internal-api", "http://localhost:5444", "Internal API endpoint")

     

       29
       -
       )

     

       30
       -
       

     

       31
       -
       func main() {

     

       32
       -
       	flag.Parse()

     

       33
       -
       

     

       34
       -
       	defer cleanup()

     

       35
       -
       	initLogger()

     

       36
       -
       

     

       37
       -
       	// Get client IP from SSH environment

     

       38
       -
       	if connInfo := os.Getenv("SSH_CONNECTION"); connInfo != "" {

     

       39
       -
       		parts := strings.Fields(connInfo)

     

       40
       -
       		if len(parts) > 0 {

     

       41
       -
       			clientIP = parts[0]

     

       42
       -
       		}

     

       43
       -
       	}

     

       44
       -
       

     

       45
       -
       	if *incomingUser == "" {

     

       46
       -
       		exitWithLog("access denied: no user specified")

     

       47
       -
       	}

     

       48
       -
       

     

       49
       -
       	sshCommand := os.Getenv("SSH_ORIGINAL_COMMAND")

     

       50
       -
       

     

       51
       -
       	logEvent("Connection attempt", map[string]interface{}{

     

       52
       -
       		"user":    *incomingUser,

     

       53
       -
       		"command": sshCommand,

     

       54
       -
       		"client":  clientIP,

     

       55
       -
       	})

     

       56
       -
       

     

       57
       -
       	if sshCommand == "" {

     

       58
       -
       		exitWithLog("access denied: we don't serve interactive shells :)")

     

       59
       -
       	}

     

       60
       -
       

     

       61
       -
       	cmdParts := strings.Fields(sshCommand)

     

       62
       -
       	if len(cmdParts) < 2 {

     

       63
       -
       		exitWithLog("invalid command format")

     

       64
       -
       	}

     

       65
       -
       

     

       66
       -
       	gitCommand := cmdParts[0]

     

       67
       -
       

     

       68
       -
       	// did:foo/repo-name or

     

       69
       -
       	// handle/repo-name or

     

       70
       -
       	// any of the above with a leading slash (/)

     

       71
       -
       

     

       72
       -
       	components := strings.Split(strings.TrimPrefix(strings.Trim(cmdParts[1], "'"), "/"), "/")

     

       73
       -
       	logEvent("Command components", map[string]interface{}{

     

       74
       -
       		"components": components,

     

       75
       -
       	})

     

       76
       -
       	if len(components) != 2 {

     

       77
       -
       		exitWithLog("invalid repo format, needs <user>/<repo> or /<user>/<repo>")

     

       78
       -
       	}

     

       79
       -
       

     

       80
       -
       	didOrHandle := components[0]

     

       81
       -
       	did := resolveToDid(didOrHandle)

     

       82
       -
       	repoName := components[1]

     

       83
       -
       	qualifiedRepoName, _ := securejoin.SecureJoin(did, repoName)

     

       84
       -
       

     

       85
       -
       	validCommands := map[string]bool{

     

       86
       -
       		"git-receive-pack":   true,

     

       87
       -
       		"git-upload-pack":    true,

     

       88
       -
       		"git-upload-archive": true,

     

       89
       -
       	}

     

       90
       -
       	if !validCommands[gitCommand] {

     

       91
       -
       		exitWithLog("access denied: invalid git command")

     

       92
       -
       	}

     

       93
       -
       

     

       94
       -
       	if gitCommand != "git-upload-pack" {

     

       95
       -
       		if !isPushPermitted(*incomingUser, qualifiedRepoName) {

     

       96
       -
       			logEvent("all infos", map[string]interface{}{

     

       97
       -
       				"did":      *incomingUser,

     

       98
       -
       				"reponame": qualifiedRepoName,

     

       99
       -
       			})

     

       100
       -
       			exitWithLog("access denied: user not allowed")

     

       101
       -
       		}

     

       102
       -
       	}

     

       103
       -
       

     

       104
       -
       	fullPath, _ := securejoin.SecureJoin(*baseDirFlag, qualifiedRepoName)

     

       105
       -
       

     

       106
       -
       	logEvent("Processing command", map[string]interface{}{

     

       107
       -
       		"user":     *incomingUser,

     

       108
       -
       		"command":  gitCommand,

     

       109
       -
       		"repo":     repoName,

     

       110
       -
       		"fullPath": fullPath,

     

       111
       -
       		"client":   clientIP,

     

       112
       -
       	})

     

       113
       -
       

     

       114
       -
       	if gitCommand == "git-upload-pack" {

     

       115
       -
       		fmt.Fprintf(os.Stderr, "\x02%s\n", "Welcome to this knot!")

     

       116
       -
       	} else {

     

       117
       -
       		fmt.Fprintf(os.Stderr, "%s\n", "Welcome to this knot!")

     

       118
       -
       	}

     

       119
       -
       

     

       120
       -
       	cmd := exec.Command(gitCommand, fullPath)

     

       121
       -
       	cmd.Stdout = os.Stdout

     

       122
       -
       	cmd.Stderr = os.Stderr

     

       123
       -
       	cmd.Stdin = os.Stdin

     

       124
       -
       

     

       125
       -
       	if err := cmd.Run(); err != nil {

     

       126
       -
       		exitWithLog(fmt.Sprintf("command failed: %v", err))

     

       127
       -
       	}

     

       128
       -
       

     

       129
       -
       	logEvent("Command completed", map[string]interface{}{

     

       130
       -
       		"user":    *incomingUser,

     

       131
       -
       		"command": gitCommand,

     

       132
       -
       		"repo":    repoName,

     

       133
       -
       		"success": true,

     

       134
       -
       	})

     

       135
       -
       }

     

       136
       -
       

     

       137
       -
       func resolveToDid(didOrHandle string) string {

     

       138
       -
       	resolver := idresolver.DefaultResolver()

     

       139
       -
       	ident, err := resolver.ResolveIdent(context.Background(), didOrHandle)

     

       140
       -
       	if err != nil {

     

       141
       -
       		exitWithLog(fmt.Sprintf("error resolving handle: %v", err))

     

       142
       -
       	}

     

       143
       -
       

     

       144
       -
       	// did:plc:foobarbaz/repo

     

       145
       -
       	return ident.DID.String()

     

       146
       -
       }

     

       147
       -
       

     

       148
       -
       func initLogger() {

     

       149
       -
       	var err error

     

       150
       -
       	logFile, err = os.OpenFile(*logPathFlag, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)

     

       151
       -
       	if err != nil {

     

       152
       -
       		fmt.Fprintf(os.Stderr, "failed to open log file: %v\n", err)

     

       153
       -
       		os.Exit(1)

     

       154
       -
       	}

     

       155
       -
       

     

       156
       -
       	logger = log.New(logFile, "", 0)

     

       157
       -
       }

     

       158
       -
       

     

       159
       -
       func logEvent(event string, fields map[string]interface{}) {

     

       160
       -
       	entry := fmt.Sprintf(

     

       161
       -
       		"timestamp=%q event=%q",

     

       162
       -
       		time.Now().Format(time.RFC3339),

     

       163
       -
       		event,

     

       164
       -
       	)

     

       165
       -
       

     

       166
       -
       	for k, v := range fields {

     

       167
       -
       		entry += fmt.Sprintf(" %s=%q", k, v)

     

       168
       -
       	}

     

       169
       -
       

     

       170
       -
       	logger.Println(entry)

     

       171
       -
       }

     

       172
       -
       

     

       173
       -
       func exitWithLog(message string) {

     

       174
       -
       	logEvent("Access denied", map[string]interface{}{

     

       175
       -
       		"error": message,

     

       176
       -
       	})

     

       177
       -
       	logFile.Sync()

     

       178
       -
       	fmt.Fprintf(os.Stderr, "error: %s\n", message)

     

       179
       -
       	os.Exit(1)

     

       180
       -
       }

     

       181
       -
       

     

       182
       -
       func cleanup() {

     

       183
       -
       	if logFile != nil {

     

       184
       -
       		logFile.Sync()

     

       185
       -
       		logFile.Close()

     

       186
       -
       	}

     

       187
       -
       }

     

       188
       -
       

     

       189
       -
       func isPushPermitted(user, qualifiedRepoName string) bool {

     

       190
       -
       	u, _ := url.Parse(*endpoint + "/push-allowed")

     

       191
       -
       	q := u.Query()

     

       192
       -
       	q.Add("user", user)

     

       193
       -
       	q.Add("repo", qualifiedRepoName)

     

       194
       -
       	u.RawQuery = q.Encode()

     

       195
       -
       

     

       196
       -
       	req, err := http.Get(u.String())

     

       197
       -
       	if err != nil {

     

       198
       -
       		exitWithLog(fmt.Sprintf("error verifying permissions: %v", err))

     

       199
       -
       	}

     

       200
       -
       

     

       201
       -
       	logEvent("url", map[string]interface{}{

     

       202
       -
       		"url":    u.String(),

     

       203
       -
       		"status": req.Status,

     

       204
       -
       	})

     

       205
       -
       

     

       206
       -
       	return req.StatusCode == http.StatusNoContent

     

       207
       -
       }

+168

knotserver/git/last_commit.go

···

       1
       +
       package git

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"bufio"

     

       5
       +
       	"context"

     

       6
       +
       	"crypto/sha256"

     

       7
       +
       	"fmt"

     

       8
       +
       	"io"

     

       9
       +
       	"os/exec"

     

       10
       +
       	"path"

     

       11
       +
       	"strings"

     

       12
       +
       	"time"

     

       13
       +
       

     

       14
       +
       	"github.com/dgraph-io/ristretto"

     

       15
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       16
       +
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       17
       +
       )

     

       18
       +
       

     

       19
       +
       var (

     

       20
       +
       	commitCache *ristretto.Cache

     

       21
       +
       )

     

       22
       +
       

     

       23
       +
       func init() {

     

       24
       +
       	cache, _ := ristretto.NewCache(&ristretto.Config{

     

       25
       +
       		NumCounters:            1e7,

     

       26
       +
       		MaxCost:                1 << 30,

     

       27
       +
       		BufferItems:            64,

     

       28
       +
       		TtlTickerDurationInSec: 120,

     

       29
       +
       	})

     

       30
       +
       	commitCache = cache

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       func (g *GitRepo) streamingGitLog(ctx context.Context, extraArgs ...string) (io.Reader, error) {

     

       34
       +
       	args := []string{}

     

       35
       +
       	args = append(args, "log")

     

       36
       +
       	args = append(args, g.h.String())

     

       37
       +
       	args = append(args, extraArgs...)

     

       38
       +
       

     

       39
       +
       	cmd := exec.CommandContext(ctx, "git", args...)

     

       40
       +
       	cmd.Dir = g.path

     

       41
       +
       

     

       42
       +
       	stdout, err := cmd.StdoutPipe()

     

       43
       +
       	if err != nil {

     

       44
       +
       		return nil, err

     

       45
       +
       	}

     

       46
       +
       

     

       47
       +
       	if err := cmd.Start(); err != nil {

     

       48
       +
       		return nil, err

     

       49
       +
       	}

     

       50
       +
       

     

       51
       +
       	return stdout, nil

     

       52
       +
       }

     

       53
       +
       

     

       54
       +
       type commit struct {

     

       55
       +
       	hash    plumbing.Hash

     

       56
       +
       	when    time.Time

     

       57
       +
       	files   []string

     

       58
       +
       	message string

     

       59
       +
       }

     

       60
       +
       

     

       61
       +
       func cacheKey(g *GitRepo, path string) string {

     

       62
       +
       	sep := byte(':')

     

       63
       +
       	hash := sha256.Sum256(fmt.Append([]byte{}, g.path, sep, g.h.String(), sep, path))

     

       64
       +
       	return fmt.Sprintf("%x", hash)

     

       65
       +
       }

     

       66
       +
       

     

       67
       +
       func (g *GitRepo) calculateCommitTimeIn(ctx context.Context, subtree *object.Tree, parent string, timeout time.Duration) (map[string]commit, error) {

     

       68
       +
       	ctx, cancel := context.WithTimeout(ctx, timeout)

     

       69
       +
       	defer cancel()

     

       70
       +
       	return g.calculateCommitTime(ctx, subtree, parent)

     

       71
       +
       }

     

       72
       +
       

     

       73
       +
       func (g *GitRepo) calculateCommitTime(ctx context.Context, subtree *object.Tree, parent string) (map[string]commit, error) {

     

       74
       +
       	filesToDo := make(map[string]struct{})

     

       75
       +
       	filesDone := make(map[string]commit)

     

       76
       +
       	for _, e := range subtree.Entries {

     

       77
       +
       		fpath := path.Clean(path.Join(parent, e.Name))

     

       78
       +
       		filesToDo[fpath] = struct{}{}

     

       79
       +
       	}

     

       80
       +
       

     

       81
       +
       	for _, e := range subtree.Entries {

     

       82
       +
       		f := path.Clean(path.Join(parent, e.Name))

     

       83
       +
       		cacheKey := cacheKey(g, f)

     

       84
       +
       		if cached, ok := commitCache.Get(cacheKey); ok {

     

       85
       +
       			filesDone[f] = cached.(commit)

     

       86
       +
       			delete(filesToDo, f)

     

       87
       +
       		} else {

     

       88
       +
       			filesToDo[f] = struct{}{}

     

       89
       +
       		}

     

       90
       +
       	}

     

       91
       +
       

     

       92
       +
       	if len(filesToDo) == 0 {

     

       93
       +
       		return filesDone, nil

     

       94
       +
       	}

     

       95
       +
       

     

       96
       +
       	ctx, cancel := context.WithCancel(ctx)

     

       97
       +
       	defer cancel()

     

       98
       +
       

     

       99
       +
       	pathSpec := "."

     

       100
       +
       	if parent != "" {

     

       101
       +
       		pathSpec = parent

     

       102
       +
       	}

     

       103
       +
       	output, err := g.streamingGitLog(ctx, "--pretty=format:%H,%ad,%s", "--date=iso", "--name-only", "--", pathSpec)

     

       104
       +
       	if err != nil {

     

       105
       +
       		return nil, err

     

       106
       +
       	}

     

       107
       +
       

     

       108
       +
       	reader := bufio.NewReader(output)

     

       109
       +
       	var current commit

     

       110
       +
       	for {

     

       111
       +
       		line, err := reader.ReadString('\n')

     

       112
       +
       		if err != nil && err != io.EOF {

     

       113
       +
       			return nil, err

     

       114
       +
       		}

     

       115
       +
       		line = strings.TrimSpace(line)

     

       116
       +
       

     

       117
       +
       		if line == "" {

     

       118
       +
       			if !current.hash.IsZero() {

     

       119
       +
       				// we have a fully parsed commit

     

       120
       +
       				for _, f := range current.files {

     

       121
       +
       					if _, ok := filesToDo[f]; ok {

     

       122
       +
       						filesDone[f] = current

     

       123
       +
       						delete(filesToDo, f)

     

       124
       +
       						commitCache.Set(cacheKey(g, f), current, 0)

     

       125
       +
       					}

     

       126
       +
       				}

     

       127
       +
       

     

       128
       +
       				if len(filesToDo) == 0 {

     

       129
       +
       					cancel()

     

       130
       +
       					break

     

       131
       +
       				}

     

       132
       +
       				current = commit{}

     

       133
       +
       			}

     

       134
       +
       		} else if current.hash.IsZero() {

     

       135
       +
       			parts := strings.SplitN(line, ",", 3)

     

       136
       +
       			if len(parts) == 3 {

     

       137
       +
       				current.hash = plumbing.NewHash(parts[0])

     

       138
       +
       				current.when, _ = time.Parse("2006-01-02 15:04:05 -0700", parts[1])

     

       139
       +
       				current.message = parts[2]

     

       140
       +
       			}

     

       141
       +
       		} else {

     

       142
       +
       			// all ancestors along this path should also be included

     

       143
       +
       			file := path.Clean(line)

     

       144
       +
       			ancestors := ancestors(file)

     

       145
       +
       			current.files = append(current.files, file)

     

       146
       +
       			current.files = append(current.files, ancestors...)

     

       147
       +
       		}

     

       148
       +
       

     

       149
       +
       		if err == io.EOF {

     

       150
       +
       			break

     

       151
       +
       		}

     

       152
       +
       	}

     

       153
       +
       

     

       154
       +
       	return filesDone, nil

     

       155
       +
       }

     

       156
       +
       

     

       157
       +
       func ancestors(p string) []string {

     

       158
       +
       	var ancestors []string

     

       159
       +
       

     

       160
       +
       	for {

     

       161
       +
       		p = path.Dir(p)

     

       162
       +
       		if p == "." || p == "/" {

     

       163
       +
       			break

     

       164
       +
       		}

     

       165
       +
       		ancestors = append(ancestors, p)

     

       166
       +
       	}

     

       167
       +
       	return ancestors

     

       168
       +
       }

-71

cmd/knotserver/main.go

···

       1
       -
       package main

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"context"

     

       5
       -
       	"net/http"

     

       6
       -
       

     

       7
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       8
       -
       	"tangled.sh/tangled.sh/core/jetstream"

     

       9
       -
       	"tangled.sh/tangled.sh/core/knotserver"

     

       10
       -
       	"tangled.sh/tangled.sh/core/knotserver/config"

     

       11
       -
       	"tangled.sh/tangled.sh/core/knotserver/db"

     

       12
       -
       	"tangled.sh/tangled.sh/core/log"

     

       13
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       14
       -
       

     

       15
       -
       	_ "net/http/pprof"

     

       16
       -
       )

     

       17
       -
       

     

       18
       -
       func main() {

     

       19
       -
       	ctx := context.Background()

     

       20
       -
       	// ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)

     

       21
       -
       	// defer stop()

     

       22
       -
       

     

       23
       -
       	l := log.New("knotserver")

     

       24
       -
       

     

       25
       -
       	c, err := config.Load(ctx)

     

       26
       -
       	if err != nil {

     

       27
       -
       		l.Error("failed to load config", "error", err)

     

       28
       -
       		return

     

       29
       -
       	}

     

       30
       -
       

     

       31
       -
       	if c.Server.Dev {

     

       32
       -
       		l.Info("running in dev mode, signature verification is disabled")

     

       33
       -
       	}

     

       34
       -
       

     

       35
       -
       	db, err := db.Setup(c.Server.DBPath)

     

       36
       -
       	if err != nil {

     

       37
       -
       		l.Error("failed to setup db", "error", err)

     

       38
       -
       		return

     

       39
       -
       	}

     

       40
       -
       

     

       41
       -
       	e, err := rbac.NewEnforcer(c.Server.DBPath)

     

       42
       -
       	if err != nil {

     

       43
       -
       		l.Error("failed to setup rbac enforcer", "error", err)

     

       44
       -
       		return

     

       45
       -
       	}

     

       46
       -
       

     

       47
       -
       	e.E.EnableAutoSave(true)

     

       48
       -
       

     

       49
       -
       	jc, err := jetstream.NewJetstreamClient(c.Server.JetstreamEndpoint, "knotserver", []string{

     

       50
       -
       		tangled.PublicKeyNSID,

     

       51
       -
       		tangled.KnotMemberNSID,

     

       52
       -
       	}, nil, l, db, true)

     

       53
       -
       	if err != nil {

     

       54
       -
       		l.Error("failed to setup jetstream", "error", err)

     

       55
       -
       	}

     

       56
       -
       

     

       57
       -
       	mux, err := knotserver.Setup(ctx, c, db, e, jc, l)

     

       58
       -
       	if err != nil {

     

       59
       -
       		l.Error("failed to setup server", "error", err)

     

       60
       -
       		return

     

       61
       -
       	}

     

       62
       -
       	imux := knotserver.Internal(ctx, db, e)

     

       63
       -
       

     

       64
       -
       	l.Info("starting internal server", "address", c.Server.InternalListenAddr)

     

       65
       -
       	go http.ListenAndServe(c.Server.InternalListenAddr, imux)

     

       66
       -
       

     

       67
       -
       	l.Info("starting main server", "address", c.Server.ListenAddr)

     

       68
       -
       	l.Error("server error", "error", http.ListenAndServe(c.Server.ListenAddr, mux))

     

       69
       -
       

     

       70
       -
       	return

     

       71
       -
       }

+1 -1

systemd/knotserver.service

···

       4
        
       

     

       5
        
       

     

       6
        
       [Service]

     

       7
       -
       ExecStart=/usr/local/bin/knotserver

     

       8
        
       Restart=always

     

       9
        
       User=git

     

       10
        
       WorkingDirectory=/home/git

···

       4
        
       

     

       5
        
       

     

       6
        
       [Service]

     

       7
       +
       ExecStart=/usr/local/bin/knot server

     

       8
        
       Restart=always

     

       9
        
       User=git

     

       10
        
       WorkingDirectory=/home/git

+43

knotserver/notifier/notifier.go

···

       1
       +
       package notifier

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"sync"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type Notifier struct {

     

       8
       +
       	subscribers map[chan struct{}]struct{}

     

       9
       +
       	mu          sync.Mutex

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       func New() Notifier {

     

       13
       +
       	return Notifier{

     

       14
       +
       		subscribers: make(map[chan struct{}]struct{}),

     

       15
       +
       	}

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       func (n *Notifier) Subscribe() chan struct{} {

     

       19
       +
       	ch := make(chan struct{}, 1)

     

       20
       +
       	n.mu.Lock()

     

       21
       +
       	n.subscribers[ch] = struct{}{}

     

       22
       +
       	n.mu.Unlock()

     

       23
       +
       	return ch

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       func (n *Notifier) Unsubscribe(ch chan struct{}) {

     

       27
       +
       	n.mu.Lock()

     

       28
       +
       	delete(n.subscribers, ch)

     

       29
       +
       	close(ch)

     

       30
       +
       	n.mu.Unlock()

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       func (n *Notifier) NotifyAll() {

     

       34
       +
       	n.mu.Lock()

     

       35
       +
       	for ch := range n.subscribers {

     

       36
       +
       		select {

     

       37
       +
       		case ch <- struct{}{}:

     

       38
       +
       		default:

     

       39
       +
       			// avoid blocking if channel is full

     

       40
       +
       		}

     

       41
       +
       	}

     

       42
       +
       	n.mu.Unlock()

     

       43
       +
       }

-33

docker/docker-compose.yml

···

       1
       -
       services:

     

       2
       -
         knot:

     

       3
       -
           build:

     

       4
       -
             context: ..

     

       5
       -
             dockerfile: docker/Dockerfile

     

       6
       -
           environment:

     

       7
       -
             KNOT_SERVER_HOSTNAME: ${KNOT_SERVER_HOSTNAME}

     

       8
       -
             KNOT_SERVER_SECRET: ${KNOT_SERVER_SECRET}

     

       9
       -
             KNOT_SERVER_DB_PATH: "/app/knotserver.db"

     

       10
       -
             KNOT_REPO_SCAN_PATH: "/home/git/repositories"

     

       11
       -
           volumes:

     

       12
       -
             - "./keys:/etc/ssh/keys"

     

       13
       -
             - "./repositories:/home/git/repositories"

     

       14
       -
             - "./server:/app"

     

       15
       -
           ports:

     

       16
       -
             - "2222:22"

     

       17
       -
         frontend:

     

       18
       -
           image: caddy:2-alpine

     

       19
       -
           command: >

     

       20
       -
             caddy

     

       21
       -
             reverse-proxy

     

       22
       -
             --from ${KNOT_SERVER_HOSTNAME}

     

       23
       -
             --to knot:5555

     

       24
       -
           depends_on:

     

       25
       -
             - knot

     

       26
       -
           ports:

     

       27
       -
             - "443:443"

     

       28
       -
             - "443:443/udp"

     

       29
       -
           volumes:

     

       30
       -
             - caddy_data:/data

     

       31
       -
           restart: always

     

       32
       -
       volumes:

     

       33
       -
         caddy_data:

-1

docker/rootfs/etc/s6-overlay/s6-rc.d/create-sshd-host-keys/type

···

       1
       -
       oneshot

···

       0

-1

docker/rootfs/etc/s6-overlay/s6-rc.d/create-sshd-host-keys/up

···

       1
       -
       /etc/s6-overlay/scripts/create-sshd-host-keys

···

       0

docker/rootfs/etc/s6-overlay/s6-rc.d/knotserver/dependencies.d/base

-1

docker/rootfs/etc/s6-overlay/s6-rc.d/knotserver/type

···

       1
       -
       longrun

···

       0

docker/rootfs/etc/s6-overlay/s6-rc.d/sshd/dependencies.d/base

docker/rootfs/etc/s6-overlay/s6-rc.d/sshd/dependencies.d/create-sshd-host-keys

-3

docker/rootfs/etc/s6-overlay/s6-rc.d/sshd/run

···

       1
       -
       #!/usr/bin/execlineb -P

     

       2
       -
       

     

       3
       -
       /usr/sbin/sshd -e -D

-1

docker/rootfs/etc/s6-overlay/s6-rc.d/sshd/type

···

       1
       -
       longrun

···

       0

docker/rootfs/etc/s6-overlay/s6-rc.d/user/contents.d/knotserver

docker/rootfs/etc/s6-overlay/s6-rc.d/user/contents.d/sshd

-21

docker/rootfs/etc/s6-overlay/scripts/create-sshd-host-keys

···

       1
       -
       #!/usr/bin/execlineb -P

     

       2
       -
       

     

       3
       -
       foreground {

     

       4
       -
         if -n { test -d /etc/ssh/keys }

     

       5
       -
         mkdir /etc/ssh/keys

     

       6
       -
       }

     

       7
       -
       

     

       8
       -
       foreground {

     

       9
       -
         if -n { test -f /etc/ssh/keys/ssh_host_rsa_key }

     

       10
       -
         ssh-keygen -t rsa -f /etc/ssh/keys/ssh_host_rsa_key -q -N ""

     

       11
       -
       }

     

       12
       -
       

     

       13
       -
       foreground {

     

       14
       -
         if -n { test -f /etc/ssh/keys/ssh_host_ecdsa_key }

     

       15
       -
         ssh-keygen -t rsa -f /etc/ssh/keys/ssh_host_ecdsa_key -q -N ""

     

       16
       -
       }

     

       17
       -
       

     

       18
       -
       foreground {

     

       19
       -
         if -n { test -f /etc/ssh/keys/ssh_host_ed25519_key }

     

       20
       -
         ssh-keygen -t rsa -f /etc/ssh/keys/ssh_host_ed25519_key -q -N ""

     

       21
       -
       }

+14

appview/cache/cache.go

···

       1
       +
       package cache

     

       2
       +
       

     

       3
       +
       import "github.com/redis/go-redis/v9"

     

       4
       +
       

     

       5
       +
       type Cache struct {

     

       6
       +
       	*redis.Client

     

       7
       +
       }

     

       8
       +
       

     

       9
       +
       func New(addr string) *Cache {

     

       10
       +
       	rdb := redis.NewClient(&redis.Options{

     

       11
       +
       		Addr: addr,

     

       12
       +
       	})

     

       13
       +
       	return &Cache{rdb}

     

       14
       +
       }

+18

nix/pkgs/sqlite-lib.nix

···

       1
       +
       {

     

       2
       +
         gcc,

     

       3
       +
         stdenv,

     

       4
       +
         sqlite-lib-src,

     

       5
       +
       }:

     

       6
       +
       stdenv.mkDerivation {

     

       7
       +
         name = "sqlite-lib";

     

       8
       +
         src = sqlite-lib-src;

     

       9
       +
         nativeBuildInputs = [gcc];

     

       10
       +
         buildPhase = ''

     

       11
       +
           gcc -c sqlite3.c

     

       12
       +
           ar rcs libsqlite3.a sqlite3.o

     

       13
       +
           ranlib libsqlite3.a

     

       14
       +
           mkdir -p $out/include $out/lib

     

       15
       +
           cp *.h $out/include

     

       16
       +
           cp libsqlite3.a $out/lib

     

       17
       +
         '';

     

       18
       +
       }

+20

nix/pkgs/knot.nix

···

       1
       +
       {

     

       2
       +
         knot-unwrapped,

     

       3
       +
         makeWrapper,

     

       4
       +
         git,

     

       5
       +
       }:

     

       6
       +
       knot-unwrapped.overrideAttrs (after: before: {

     

       7
       +
         nativeBuildInputs = (before.nativeBuildInputs or []) ++ [makeWrapper];

     

       8
       +
       

     

       9
       +
         installPhase = ''

     

       10
       +
           runHook preInstall

     

       11
       +
       

     

       12
       +
           mkdir -p $out/bin

     

       13
       +
           cp $GOPATH/bin/knot $out/bin/knot

     

       14
       +
       

     

       15
       +
           wrapProgram $out/bin/knot \

     

       16
       +
           --prefix PATH : ${git}/bin

     

       17
       +
       

     

       18
       +
           runHook postInstall

     

       19
       +
         '';

     

       20
       +
       })

-70

knotserver/db/oplog.go

···

       1
       -
       package db

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"fmt"

     

       5
       -
       

     

       6
       -
       	"tangled.sh/tangled.sh/core/knotserver/notifier"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       type Op struct {

     

       10
       -
       	Tid    string // time based ID, easy to enumerate & monotonic

     

       11
       -
       	Did    string // did of pusher

     

       12
       -
       	Repo   string // <did/repo> fully qualified repo

     

       13
       -
       	OldSha string // old sha of reference being updated

     

       14
       -
       	NewSha string // new sha of reference being updated

     

       15
       -
       	Ref    string // the reference being updated

     

       16
       -
       }

     

       17
       -
       

     

       18
       -
       func (d *DB) InsertOp(op Op, notifier *notifier.Notifier) error {

     

       19
       -
       	_, err := d.db.Exec(

     

       20
       -
       		`insert into oplog (tid, did, repo, old_sha, new_sha, ref) values (?, ?, ?, ?, ?, ?)`,

     

       21
       -
       		op.Tid,

     

       22
       -
       		op.Did,

     

       23
       -
       		op.Repo,

     

       24
       -
       		op.OldSha,

     

       25
       -
       		op.NewSha,

     

       26
       -
       		op.Ref,

     

       27
       -
       	)

     

       28
       -
       	if err != nil {

     

       29
       -
       		return err

     

       30
       -
       	}

     

       31
       -
       

     

       32
       -
       	notifier.NotifyAll()

     

       33
       -
       	return nil

     

       34
       -
       }

     

       35
       -
       

     

       36
       -
       func (d *DB) GetOps(cursor string) ([]Op, error) {

     

       37
       -
       	whereClause := ""

     

       38
       -
       	args := []any{}

     

       39
       -
       	if cursor != "" {

     

       40
       -
       		whereClause = "where tid > ?"

     

       41
       -
       		args = append(args, cursor)

     

       42
       -
       	}

     

       43
       -
       

     

       44
       -
       	query := fmt.Sprintf(`

     

       45
       -
       		select tid, did, repo, old_sha, new_sha, ref

     

       46
       -
       		from oplog

     

       47
       -
       		%s

     

       48
       -
       		order by tid asc

     

       49
       -
       		limit 100

     

       50
       -
       	`, whereClause)

     

       51
       -
       

     

       52
       -
       	rows, err := d.db.Query(query, args...)

     

       53
       -
       	if err != nil {

     

       54
       -
       		return nil, err

     

       55
       -
       	}

     

       56
       -
       	defer rows.Close()

     

       57
       -
       

     

       58
       -
       	var ops []Op

     

       59
       -
       	for rows.Next() {

     

       60
       -
       		var op Op

     

       61
       -
       		rows.Scan(&op.Tid, &op.Did, &op.Repo, &op.OldSha, &op.NewSha, &op.Ref)

     

       62
       -
       		ops = append(ops, op)

     

       63
       -
       	}

     

       64
       -
       

     

       65
       -
       	if err := rows.Err(); err != nil {

     

       66
       -
       		return nil, err

     

       67
       -
       	}

     

       68
       -
       

     

       69
       -
       	return ops, nil

     

       70
       -
       }

spindle/tid.go

···

       1
       +
       package spindle

     

       2
       +
       

     

       3
       +
       import "github.com/bluesky-social/indigo/atproto/syntax"

     

       4
       +
       

     

       5
       +
       var TIDClock = syntax.NewTIDClock(0)

     

       6
       +
       

     

       7
       +
       func TID() string {

     

       8
       +
       	return TIDClock.Next().String()

     

       9
       +
       }

knotserver/notifier/notifier.go notifier/notifier.go

+23

knotclient/cursor/memory.go

···

       1
       +
       package cursor

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"sync"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type MemoryStore struct {

     

       8
       +
       	store sync.Map

     

       9
       +
       }

     

       10
       +
       

     

       11
       +
       func (m *MemoryStore) Set(knot string, cursor int64) {

     

       12
       +
       	m.store.Store(knot, cursor)

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func (m *MemoryStore) Get(knot string) (cursor int64) {

     

       16
       +
       	if result, ok := m.store.Load(knot); ok {

     

       17
       +
       		if val, ok := result.(int64); ok {

     

       18
       +
       			return val

     

       19
       +
       		}

     

       20
       +
       	}

     

       21
       +
       

     

       22
       +
       	return 0

     

       23
       +
       }

+43

knotclient/cursor/redis.go

···

       1
       +
       package cursor

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"fmt"

     

       6
       +
       	"strconv"

     

       7
       +
       

     

       8
       +
       	"tangled.sh/tangled.sh/core/appview/cache"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	cursorKey = "cursor:%s"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       type RedisStore struct {

     

       16
       +
       	rdb *cache.Cache

     

       17
       +
       }

     

       18
       +
       

     

       19
       +
       func NewRedisCursorStore(cache *cache.Cache) RedisStore {

     

       20
       +
       	return RedisStore{

     

       21
       +
       		rdb: cache,

     

       22
       +
       	}

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       func (r *RedisStore) Set(knot string, cursor int64) {

     

       26
       +
       	key := fmt.Sprintf(cursorKey, knot)

     

       27
       +
       	r.rdb.Set(context.Background(), key, cursor, 0)

     

       28
       +
       }

     

       29
       +
       

     

       30
       +
       func (r *RedisStore) Get(knot string) (cursor int64) {

     

       31
       +
       	key := fmt.Sprintf(cursorKey, knot)

     

       32
       +
       	val, err := r.rdb.Get(context.Background(), key).Result()

     

       33
       +
       	if err != nil {

     

       34
       +
       		return 0

     

       35
       +
       	}

     

       36
       +
       	cursor, err = strconv.ParseInt(val, 10, 64)

     

       37
       +
       	if err != nil {

     

       38
       +
       		// TODO: log here

     

       39
       +
       		return 0

     

       40
       +
       	}

     

       41
       +
       

     

       42
       +
       	return cursor

     

       43
       +
       }

knotclient/cursor/store.go

···

       1
       +
       package cursor

     

       2
       +
       

     

       3
       +
       type Store interface {

     

       4
       +
       	Set(knot string, cursor int64)

     

       5
       +
       	Get(knot string) (cursor int64)

     

       6
       +
       }

+83

knotclient/cursor/sqlite.go

···

       1
       +
       package cursor

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"database/sql"

     

       5
       +
       	"fmt"

     

       6
       +
       

     

       7
       +
       	_ "github.com/mattn/go-sqlite3"

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       type SqliteStore struct {

     

       11
       +
       	db        *sql.DB

     

       12
       +
       	tableName string

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       type SqliteStoreOpt func(*SqliteStore)

     

       16
       +
       

     

       17
       +
       func WithTableName(name string) SqliteStoreOpt {

     

       18
       +
       	return func(s *SqliteStore) {

     

       19
       +
       		s.tableName = name

     

       20
       +
       	}

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       func NewSQLiteStore(dbPath string, opts ...SqliteStoreOpt) (*SqliteStore, error) {

     

       24
       +
       	db, err := sql.Open("sqlite3", dbPath)

     

       25
       +
       	if err != nil {

     

       26
       +
       		return nil, fmt.Errorf("failed to open sqlite database: %w", err)

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	store := &SqliteStore{

     

       30
       +
       		db:        db,

     

       31
       +
       		tableName: "cursors",

     

       32
       +
       	}

     

       33
       +
       

     

       34
       +
       	for _, o := range opts {

     

       35
       +
       		o(store)

     

       36
       +
       	}

     

       37
       +
       

     

       38
       +
       	if err := store.init(); err != nil {

     

       39
       +
       		return nil, err

     

       40
       +
       	}

     

       41
       +
       

     

       42
       +
       	return store, nil

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       func (s *SqliteStore) init() error {

     

       46
       +
       	createTable := fmt.Sprintf(`

     

       47
       +
       	create table if not exists %s (

     

       48
       +
       		knot text primary key,

     

       49
       +
       		cursor text

     

       50
       +
       	);`, s.tableName)

     

       51
       +
       	_, err := s.db.Exec(createTable)

     

       52
       +
       	return err

     

       53
       +
       }

     

       54
       +
       

     

       55
       +
       func (s *SqliteStore) Set(knot string, cursor int64) {

     

       56
       +
       	query := fmt.Sprintf(`

     

       57
       +
       		insert into %s (knot, cursor)

     

       58
       +
       		values (?, ?)

     

       59
       +
       		on conflict(knot) do update set cursor=excluded.cursor;

     

       60
       +
       	`, s.tableName)

     

       61
       +
       

     

       62
       +
       	_, err := s.db.Exec(query, knot, cursor)

     

       63
       +
       

     

       64
       +
       	if err != nil {

     

       65
       +
       		// TODO: log here

     

       66
       +
       	}

     

       67
       +
       }

     

       68
       +
       

     

       69
       +
       func (s *SqliteStore) Get(knot string) (cursor int64) {

     

       70
       +
       	query := fmt.Sprintf(`

     

       71
       +
       		select cursor from %s where knot = ?;

     

       72
       +
       	`, s.tableName)

     

       73
       +
       	err := s.db.QueryRow(query, knot).Scan(&cursor)

     

       74
       +
       

     

       75
       +
       	if err != nil {

     

       76
       +
       		if err != sql.ErrNoRows {

     

       77
       +
       			// TODO: log here

     

       78
       +
       		}

     

       79
       +
       		return 0

     

       80
       +
       	}

     

       81
       +
       

     

       82
       +
       	return cursor

     

       83
       +
       }

+1 -1

spindle/tid.go tid/tid.go

···

       1
       -
       package spindle

     

       2
        
       

     

       3
        
       import "github.com/bluesky-social/indigo/atproto/syntax"

     

       4

···

       1
       +
       package tid

     

       2
        
       

     

       3
        
       import "github.com/bluesky-social/indigo/atproto/syntax"

     

       4

+44

spindle/db/known_dids.go

···

       1
       +
       package db

     

       2
       +
       

     

       3
       +
       func (d *DB) AddDid(did string) error {

     

       4
       +
       	_, err := d.Exec(`insert or ignore into known_dids (did) values (?)`, did)

     

       5
       +
       	return err

     

       6
       +
       }

     

       7
       +
       

     

       8
       +
       func (d *DB) RemoveDid(did string) error {

     

       9
       +
       	_, err := d.Exec(`delete from known_dids where did = ?`, did)

     

       10
       +
       	return err

     

       11
       +
       }

     

       12
       +
       

     

       13
       +
       func (d *DB) GetAllDids() ([]string, error) {

     

       14
       +
       	var dids []string

     

       15
       +
       

     

       16
       +
       	rows, err := d.Query(`select did from known_dids`)

     

       17
       +
       	if err != nil {

     

       18
       +
       		return nil, err

     

       19
       +
       	}

     

       20
       +
       	defer rows.Close()

     

       21
       +
       

     

       22
       +
       	for rows.Next() {

     

       23
       +
       		var did string

     

       24
       +
       		if err := rows.Scan(&did); err != nil {

     

       25
       +
       			return nil, err

     

       26
       +
       		}

     

       27
       +
       		dids = append(dids, did)

     

       28
       +
       	}

     

       29
       +
       

     

       30
       +
       	if err := rows.Err(); err != nil {

     

       31
       +
       		return nil, err

     

       32
       +
       	}

     

       33
       +
       

     

       34
       +
       	return dids, nil

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       func (d *DB) HasKnownDids() bool {

     

       38
       +
       	var count int

     

       39
       +
       	err := d.QueryRow(`select count(*) from known_dids`).Scan(&count)

     

       40
       +
       	if err != nil {

     

       41
       +
       		return false

     

       42
       +
       	}

     

       43
       +
       	return count > 0

     

       44
       +
       }

lexicons/repo.json

···

       28
        
                   "type": "string",

     

       29
        
                   "description": "knot where the repo was created"

     

       30
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
                 "description": {

     

       32
        
                   "type": "string",

     

       33
        
                   "format": "datetime",

···

       28
        
                   "type": "string",

     

       29
        
                   "description": "knot where the repo was created"

     

       30
        
                 },

     

       31
       +
                 "spindle": {

     

       32
       +
                   "type": "string",

     

       33
       +
                   "description": "CI runner to send jobs to and receive results from"

     

       34
       +
                 },

     

       35
        
                 "description": {

     

       36
        
                   "type": "string",

     

       37
        
                   "format": "datetime",

+22

api/tangled/tangledspindle.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.spindle

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	SpindleNSID = "sh.tangled.spindle"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.spindle", &Spindle{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: Spindle

     

       19
       +
       type Spindle struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.spindle" cborgen:"$type,const=sh.tangled.spindle"`

     

       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
       +
       }

+25

lexicons/spindle.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.spindle",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "any",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "createdAt"

     

       14
       +
               ],

     

       15
       +
               "properties": {

     

       16
       +
                 "createdAt": {

     

       17
       +
                   "type": "string",

     

       18
       +
                   "format": "datetime"

     

       19
       +
                 }

     

       20
       +
               }

     

       21
       +
             }

     

       22
       +
           }

     

       23
       +
         }

     

       24
       +
       }

     

       25
       +

knotclient/events.go

···

       150
        
       }

     

       151
        
       

     

       152
        
       func (c *EventConsumer) AddSource(ctx context.Context, s EventSource) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       153
        
       	c.cfgMu.Lock()

     

       154
        
       	c.cfg.Sources[s] = struct{}{}

     

       155
        
       	c.wg.Add(1)

···

       150
        
       }

     

       151
        
       

     

       152
        
       func (c *EventConsumer) AddSource(ctx context.Context, s EventSource) {

     

       153
       +
       	// we are already listening to this source

     

       154
       +
       	if _, ok := c.cfg.Sources[s]; ok {

     

       155
       +
       		c.logger.Info("source already present", "source", s)

     

       156
       +
       		return

     

       157
       +
       	}

     

       158
       +
       

     

       159
        
       	c.cfgMu.Lock()

     

       160
        
       	c.cfg.Sources[s] = struct{}{}

     

       161
        
       	c.wg.Add(1)

knotclient/cursor/memory.go eventconsumer/cursor/memory.go

knotclient/cursor/store.go eventconsumer/cursor/store.go

+39

eventconsumer/knot.go

···

       1
       +
       package eventconsumer

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       	"net/url"

     

       6
       +
       )

     

       7
       +
       

     

       8
       +
       type KnotSource struct {

     

       9
       +
       	Knot string

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       func (k KnotSource) Key() string {

     

       13
       +
       	return k.Knot

     

       14
       +
       }

     

       15
       +
       

     

       16
       +
       func (k KnotSource) Url(cursor int64, dev bool) (*url.URL, error) {

     

       17
       +
       	scheme := "wss"

     

       18
       +
       	if dev {

     

       19
       +
       		scheme = "ws"

     

       20
       +
       	}

     

       21
       +
       

     

       22
       +
       	u, err := url.Parse(scheme + "://" + k.Knot + "/events")

     

       23
       +
       	if err != nil {

     

       24
       +
       		return nil, err

     

       25
       +
       	}

     

       26
       +
       

     

       27
       +
       	if cursor != 0 {

     

       28
       +
       		query := url.Values{}

     

       29
       +
       		query.Add("cursor", fmt.Sprintf("%d", cursor))

     

       30
       +
       		u.RawQuery = query.Encode()

     

       31
       +
       	}

     

       32
       +
       	return u, nil

     

       33
       +
       }

     

       34
       +
       

     

       35
       +
       func NewKnotSource(knot string) KnotSource {

     

       36
       +
       	return KnotSource{

     

       37
       +
       		Knot: knot,

     

       38
       +
       	}

     

       39
       +
       }

+39

eventconsumer/spindle.go

···

       1
       +
       package eventconsumer

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       	"net/url"

     

       6
       +
       )

     

       7
       +
       

     

       8
       +
       type SpindleSource struct {

     

       9
       +
       	Spindle string

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       func (s SpindleSource) Key() string {

     

       13
       +
       	return s.Spindle

     

       14
       +
       }

     

       15
       +
       

     

       16
       +
       func (s SpindleSource) Url(cursor int64, dev bool) (*url.URL, error) {

     

       17
       +
       	scheme := "wss"

     

       18
       +
       	if dev {

     

       19
       +
       		scheme = "ws"

     

       20
       +
       	}

     

       21
       +
       

     

       22
       +
       	u, err := url.Parse(scheme + "://" + s.Spindle + "/events")

     

       23
       +
       	if err != nil {

     

       24
       +
       		return nil, err

     

       25
       +
       	}

     

       26
       +
       

     

       27
       +
       	if cursor != 0 {

     

       28
       +
       		query := url.Values{}

     

       29
       +
       		query.Add("cursor", fmt.Sprintf("%d", cursor))

     

       30
       +
       		u.RawQuery = query.Encode()

     

       31
       +
       	}

     

       32
       +
       	return u, nil

     

       33
       +
       }

     

       34
       +
       

     

       35
       +
       func NewSpindleSource(spindle string) SpindleSource {

     

       36
       +
       	return SpindleSource{

     

       37
       +
       		Spindle: spindle,

     

       38
       +
       	}

     

       39
       +
       }

-119

appview/pages/templates/repo/fragments/pipelineStatusSymbol.html

···

       1
       -
       {{ define "repo/fragments/pipelineStatusSymbol" }}

     

       2
       -
         <div class="group relative inline-block">

     

       3
       -
           {{ block "icon" $ }} {{ end }}

     

       4
       -
           {{ block "tooltip" $ }} {{ end }}

     

       5
       -
         </div>

     

       6
       -
       {{ end }}

     

       7
       -
       

     

       8
       -
       {{ define "icon" }}

     

       9
       -
       <div class="cursor-pointer">

     

       10
       -
         {{ $c := .Counts }}

     

       11
       -
         {{ $statuses := .Statuses }}

     

       12
       -
         {{ $total := len $statuses }}

     

       13
       -
         {{ $success := index $c "success" }}

     

       14
       -
         {{ $allPass := eq $success $total }}

     

       15
       -
       

     

       16
       -
         {{ if $allPass }}

     

       17
       -
           <div class="flex gap-1 items-center">

     

       18
       -
             {{ i "check" "size-4 text-green-600 dark:text-green-400 " }} 

     

       19
       -
             <span>{{ $total }}/{{ $total }}</span>

     

       20
       -
           </div>

     

       21
       -
         {{ else }}

     

       22
       -
           {{ $radius := f64 8 }}

     

       23
       -
           {{ $circumference := mulf64 2.0 (mulf64 3.1416 $radius) }}

     

       24
       -
           {{ $offset := 0.0 }}

     

       25
       -
           <div class="flex gap-1 items-center">

     

       26
       -
             <svg class="w-4 h-4 transform -rotate-90" viewBox="0 0 20 20">

     

       27
       -
               <circle cx="10" cy="10" r="{{ $radius }}" fill="none" stroke="#f3f4f633" stroke-width="2"/>

     

       28
       -
       

     

       29
       -
               {{ range $kind, $count := $c }}

     

       30
       -
                 {{ $color := "" }}

     

       31
       -
                 {{ if or (eq $kind "pending") (eq $kind "running") }}

     

       32
       -
                   {{ $color = "#eab308" }}

     

       33
       -
                 {{ else if eq $kind "success" }}

     

       34
       -
                   {{ $color = "#10b981" }}

     

       35
       -
                 {{ else if eq $kind "cancelled" }}

     

       36
       -
                   {{ $color = "#6b7280" }}

     

       37
       -
                 {{ else }}

     

       38
       -
                   {{ $color = "#ef4444" }}

     

       39
       -
                 {{ end }}

     

       40
       -
       

     

       41
       -
                 {{ $percent := divf64 (f64 $count) (f64 $total) }}

     

       42
       -
                 {{ $length := mulf64 $percent $circumference }}

     

       43
       -
       

     

       44
       -
                 <circle

     

       45
       -
                   cx="10" cy="10" r="{{ $radius }}"

     

       46
       -
                   fill="none"

     

       47
       -
                   stroke="{{ $color }}"

     

       48
       -
                   stroke-width="2"

     

       49
       -
                   stroke-dasharray="{{ printf "%.2f %.2f" $length (subf64 $circumference $length) }}"

     

       50
       -
                   stroke-dashoffset="{{ printf "%.2f" (negf64 $offset) }}"

     

       51
       -
                 />

     

       52
       -
                 {{ $offset = addf64 $offset $length }}

     

       53
       -
               {{ end }}

     

       54
       -
             </svg>

     

       55
       -
             <span>{{$success}}/{{ $total }}</span>

     

       56
       -
           </div>

     

       57
       -
         {{ end }}

     

       58
       -
       </div>

     

       59
       -
       {{ end }}

     

       60
       -
       

     

       61
       -
       {{ define "tooltip" }}

     

       62
       -
       <div class="absolute z-[9999] hidden group-hover:block bg-white dark:bg-gray-900 text-sm text-black dark:text-white rounded-md shadow p-2 w-80 top-full mt-2">

     

       63
       -
         <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700">

     

       64
       -
           {{ range $name, $all := .Statuses }}

     

       65
       -
           <div class="flex items-center justify-between p-1">

     

       66
       -
             {{ $lastStatus := $all.Latest }}

     

       67
       -
             {{ $kind := $lastStatus.Status.String }}

     

       68
       -
       

     

       69
       -
             {{ $icon := "dot" }}

     

       70
       -
             {{ $color := "text-gray-600 dark:text-gray-500" }}

     

       71
       -
             {{ $text := "Failed" }}

     

       72
       -
             {{ $time := "" }}

     

       73
       -
       

     

       74
       -
             {{ if eq $kind "pending" }}

     

       75
       -
               {{ $icon = "circle-dashed" }}

     

       76
       -
               {{ $color = "text-yellow-600 dark:text-yellow-500" }}

     

       77
       -
               {{ $text = "Queued" }}

     

       78
       -
               {{ $time = timeFmt $lastStatus.Created }}

     

       79
       -
             {{ else if eq $kind "running" }}

     

       80
       -
               {{ $icon = "circle-dashed" }}

     

       81
       -
               {{ $color = "text-yellow-600 dark:text-yellow-500" }}

     

       82
       -
               {{ $text = "Running" }}

     

       83
       -
               {{ $time = timeFmt $lastStatus.Created }}

     

       84
       -
             {{ else if eq $kind "success" }}

     

       85
       -
               {{ $icon = "check" }}

     

       86
       -
               {{ $color = "text-green-600 dark:text-green-500" }}

     

       87
       -
               {{ $text = "Success" }}

     

       88
       -
               {{ with $all.TimeTaken }}

     

       89
       -
                 {{ $time = durationFmt . }}

     

       90
       -
               {{ end }}

     

       91
       -
             {{ else if eq $kind "cancelled" }}

     

       92
       -
               {{ $icon = "circle-slash" }}

     

       93
       -
               {{ $color = "text-gray-600 dark:text-gray-500" }}

     

       94
       -
               {{ $text = "Cancelled" }}

     

       95
       -
               {{ with $all.TimeTaken }}

     

       96
       -
                 {{ $time = durationFmt . }}

     

       97
       -
               {{ end }}

     

       98
       -
             {{ else }}

     

       99
       -
               {{ $icon = "x" }}

     

       100
       -
               {{ $color = "text-red-600 dark:text-red-500" }}

     

       101
       -
               {{ $text = "Failed" }}

     

       102
       -
               {{ with $all.TimeTaken }}

     

       103
       -
                 {{ $time = durationFmt . }}

     

       104
       -
               {{ end }}

     

       105
       -
             {{ end }}

     

       106
       -
       

     

       107
       -
             <div id="left" class="flex items-center gap-2 flex-shrink-0">

     

       108
       -
               {{ i $icon "size-4" $color }}

     

       109
       -
               {{ $name }}

     

       110
       -
             </div>

     

       111
       -
             <div id="right" class="flex items-center gap-2 flex-shrink-0">

     

       112
       -
               <span class="font-bold">{{ $text }}</span>

     

       113
       -
               <time class="text-gray-400 dark:text-gray-600">{{ $time }}</time>

     

       114
       -
             </div>

     

       115
       -
           </div>

     

       116
       -
           {{ end }}

     

       117
       -
         </div>

     

       118
       -
       </div>

     

       119
       -
       {{ end }}

+118

appview/spindleverify/verify.go

···

       1
       +
       package spindleverify

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       	"errors"

     

       6
       +
       	"fmt"

     

       7
       +
       	"io"

     

       8
       +
       	"net/http"

     

       9
       +
       	"strings"

     

       10
       +
       	"time"

     

       11
       +
       

     

       12
       +
       	"tangled.sh/tangled.sh/core/appview/db"

     

       13
       +
       	"tangled.sh/tangled.sh/core/rbac"

     

       14
       +
       )

     

       15
       +
       

     

       16
       +
       var (

     

       17
       +
       	FetchError = errors.New("failed to fetch owner")

     

       18
       +
       )

     

       19
       +
       

     

       20
       +
       // TODO: move this to "spindleclient" or similar

     

       21
       +
       func fetchOwner(ctx context.Context, domain string, dev bool) (string, error) {

     

       22
       +
       	scheme := "https"

     

       23
       +
       	if dev {

     

       24
       +
       		scheme = "http"

     

       25
       +
       	}

     

       26
       +
       

     

       27
       +
       	url := fmt.Sprintf("%s://%s/owner", scheme, domain)

     

       28
       +
       	req, err := http.NewRequest("GET", url, nil)

     

       29
       +
       	if err != nil {

     

       30
       +
       		return "", err

     

       31
       +
       	}

     

       32
       +
       

     

       33
       +
       	client := &http.Client{

     

       34
       +
       		Timeout: 1 * time.Second,

     

       35
       +
       	}

     

       36
       +
       

     

       37
       +
       	resp, err := client.Do(req.WithContext(ctx))

     

       38
       +
       	if err != nil || resp.StatusCode != 200 {

     

       39
       +
       		return "", fmt.Errorf("failed to fetch /owner")

     

       40
       +
       	}

     

       41
       +
       

     

       42
       +
       	body, err := io.ReadAll(io.LimitReader(resp.Body, 1024)) // read atmost 1kb of data

     

       43
       +
       	if err != nil {

     

       44
       +
       		return "", fmt.Errorf("failed to read /owner response: %w", err)

     

       45
       +
       	}

     

       46
       +
       

     

       47
       +
       	did := strings.TrimSpace(string(body))

     

       48
       +
       	if did == "" {

     

       49
       +
       		return "", fmt.Errorf("empty DID in /owner response")

     

       50
       +
       	}

     

       51
       +
       

     

       52
       +
       	return did, nil

     

       53
       +
       }

     

       54
       +
       

     

       55
       +
       type OwnerMismatch struct {

     

       56
       +
       	expected string

     

       57
       +
       	observed string

     

       58
       +
       }

     

       59
       +
       

     

       60
       +
       func (e *OwnerMismatch) Error() string {

     

       61
       +
       	return fmt.Sprintf("owner mismatch: %q != %q", e.expected, e.observed)

     

       62
       +
       }

     

       63
       +
       

     

       64
       +
       func RunVerification(ctx context.Context, instance, expectedOwner string, dev bool) error {

     

       65
       +
       	// begin verification

     

       66
       +
       	observedOwner, err := fetchOwner(ctx, instance, dev)

     

       67
       +
       	if err != nil {

     

       68
       +
       		return fmt.Errorf("%w: %w", FetchError, err)

     

       69
       +
       	}

     

       70
       +
       

     

       71
       +
       	if observedOwner != expectedOwner {

     

       72
       +
       		return &OwnerMismatch{

     

       73
       +
       			expected: expectedOwner,

     

       74
       +
       			observed: observedOwner,

     

       75
       +
       		}

     

       76
       +
       	}

     

       77
       +
       

     

       78
       +
       	return nil

     

       79
       +
       }

     

       80
       +
       

     

       81
       +
       // mark this spindle as verified in the DB and add this user as its owner

     

       82
       +
       func MarkVerified(d *db.DB, e *rbac.Enforcer, instance, owner string) (int64, error) {

     

       83
       +
       	tx, err := d.Begin()

     

       84
       +
       	if err != nil {

     

       85
       +
       		return 0, fmt.Errorf("failed to create txn: %w", err)

     

       86
       +
       	}

     

       87
       +
       	defer func() {

     

       88
       +
       		tx.Rollback()

     

       89
       +
       		e.E.LoadPolicy()

     

       90
       +
       	}()

     

       91
       +
       

     

       92
       +
       	// mark this spindle as verified in the db

     

       93
       +
       	rowId, err := db.VerifySpindle(

     

       94
       +
       		tx,

     

       95
       +
       		db.FilterEq("owner", owner),

     

       96
       +
       		db.FilterEq("instance", instance),

     

       97
       +
       	)

     

       98
       +
       	if err != nil {

     

       99
       +
       		return 0, fmt.Errorf("failed to write to DB: %w", err)

     

       100
       +
       	}

     

       101
       +
       

     

       102
       +
       	err = e.AddSpindleOwner(instance, owner)

     

       103
       +
       	if err != nil {

     

       104
       +
       		return 0, fmt.Errorf("failed to update ACL: %w", err)

     

       105
       +
       	}

     

       106
       +
       

     

       107
       +
       	err = tx.Commit()

     

       108
       +
       	if err != nil {

     

       109
       +
       		return 0, fmt.Errorf("failed to commit txn: %w", err)

     

       110
       +
       	}

     

       111
       +
       

     

       112
       +
       	err = e.E.SavePolicy()

     

       113
       +
       	if err != nil {

     

       114
       +
       		return 0, fmt.Errorf("failed to update ACL: %w", err)

     

       115
       +
       	}

     

       116
       +
       

     

       117
       +
       	return rowId, nil

     

       118
       +
       }

+27 -12

spindle/engine/logger.go

···

       41
        
       

     

       42
        
       func (l *WorkflowLogger) DataWriter(stream string) io.Writer {

     

       43
        
       	// TODO: emit stream

     

       44
       -
       	return &jsonWriter{logger: l, kind: models.LogKindData}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
       }

     

       46
        
       

     

       47
       -
       func (l *WorkflowLogger) ControlWriter() io.Writer {

     

       48
       -
       	return &jsonWriter{logger: l, kind: models.LogKindControl}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       49
        
       }

     

       50
        
       

     

       51
       -
       type jsonWriter struct {

     

       52
        
       	logger *WorkflowLogger

     

       53
       -
       	kind   models.LogKind

     

       54
        
       }

     

       55
        
       

     

       56
       -
       func (w *jsonWriter) Write(p []byte) (int, error) {

     

       57
        
       	line := strings.TrimRight(string(p), "\r\n")

     

       58
       -
       

     

       59
       -
       	entry := models.LogLine{

     

       60
       -
       		Kind:    w.kind,

     

       61
       -
       		Content: line,

     

       62
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       

     

       0
        
       
     

       0
        
       
     

       64
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       65
        
       		return 0, err

     

       66
        
       	}

     

       67
       -
       

     

       68
       -
       	return len(p), nil

     

       69
        
       }

···

       41
        
       

     

       42
        
       func (l *WorkflowLogger) DataWriter(stream string) io.Writer {

     

       43
        
       	// TODO: emit stream

     

       44
       +
       	return &dataWriter{

     

       45
       +
       		logger: l,

     

       46
       +
       		stream: stream,

     

       47
       +
       	}

     

       48
        
       }

     

       49
        
       

     

       50
       +
       func (l *WorkflowLogger) ControlWriter(idx int, step models.Step) io.Writer {

     

       51
       +
       	return &controlWriter{

     

       52
       +
       		logger: l,

     

       53
       +
       		idx:    idx,

     

       54
       +
       		step:   step,

     

       55
       +
       	}

     

       56
        
       }

     

       57
        
       

     

       58
       +
       type dataWriter struct {

     

       59
        
       	logger *WorkflowLogger

     

       60
       +
       	stream string

     

       61
        
       }

     

       62
        
       

     

       63
       +
       func (w *dataWriter) Write(p []byte) (int, error) {

     

       64
        
       	line := strings.TrimRight(string(p), "\r\n")

     

       65
       +
       	entry := models.NewDataLogLine(line, w.stream)

     

       66
       +
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       67
       +
       		return 0, err

     

       0
        
       
     

       68
        
       	}

     

       69
       +
       	return len(p), nil

     

       70
       +
       }

     

       71
       +
       

     

       72
       +
       type controlWriter struct {

     

       73
       +
       	logger *WorkflowLogger

     

       74
       +
       	idx    int

     

       75
       +
       	step   models.Step

     

       76
       +
       }

     

       77
        
       

     

       78
       +
       func (w *controlWriter) Write(_ []byte) (int, error) {

     

       79
       +
       	entry := models.NewControlLogLine(w.idx, w.step)

     

       80
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       81
        
       		return 0, err

     

       82
        
       	}

     

       83
       +
       	return len(w.step.Name), nil

     

       0
        
       
     

       84
        
       }

+85 -54

lexicons/pipeline.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["triggerMetadata", "workflows"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "triggerMetadata": {

     

       15
        
                   "type": "ref",

     
···

       27
        
           },

     

       28
        
           "triggerMetadata": {

     

       29
        
             "type": "object",

     

       30
       -
             "required": ["kind", "repo"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
             "properties": {

     

       32
        
               "kind": {

     

       33
        
                 "type": "string",

     

       34
       -
                 "enum": ["push", "pull_request", "manual"]

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
               },

     

       36
        
               "repo": {

     

       37
        
                 "type": "ref",

     
···

       53
        
           },

     

       54
        
           "triggerRepo": {

     

       55
        
             "type": "object",

     

       56
       -
             "required": ["knot", "did", "repo", "defaultBranch"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       57
        
             "properties": {

     

       58
        
               "knot": {

     

       59
        
                 "type": "string"

     
···

       72
        
           },

     

       73
        
           "pushTriggerData": {

     

       74
        
             "type": "object",

     

       75
       -
             "required": ["ref", "newSha", "oldSha"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       76
        
             "properties": {

     

       77
        
               "ref": {

     

       78
        
                 "type": "string"

     
···

       91
        
           },

     

       92
        
           "pullRequestTriggerData": {

     

       93
        
             "type": "object",

     

       94
       -
             "required": ["sourceBranch", "targetBranch", "sourceSha", "action"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
             "properties": {

     

       96
        
               "sourceBranch": {

     

       97
        
                 "type": "string"

     
···

       115
        
               "inputs": {

     

       116
        
                 "type": "array",

     

       117
        
                 "items": {

     

       118
       -
                   "type": "object",

     

       119
       -
                   "required": ["key", "value"],

     

       120
       -
                   "properties": {

     

       121
       -
                     "key": {

     

       122
       -
                       "type": "string"

     

       123
       -
                     },

     

       124
       -
                     "value": {

     

       125
       -
                       "type": "string"

     

       126
       -
                     }

     

       127
       -
                   }

     

       128
        
                 }

     

       129
        
               }

     

       130
        
             }

     

       131
        
           },

     

       132
        
           "workflow": {

     

       133
        
             "type": "object",

     

       134
       -
             "required": ["name", "dependencies", "steps", "environment", "clone"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       135
        
             "properties": {

     

       136
        
               "name": {

     

       137
        
                 "type": "string"

     

       138
        
               },

     

       139
        
               "dependencies": {

     

       140
       -
                 "type": "ref",

     

       141
       -
                 "ref": "#dependencies"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       142
        
               },

     

       143
        
               "steps": {

     

       144
        
                 "type": "array",

     
···

       150
        
               "environment": {

     

       151
        
                 "type": "array",

     

       152
        
                 "items": {

     

       153
       -
                   "type": "object",

     

       154
       -
                   "required": ["key", "value"],

     

       155
       -
                   "properties": {

     

       156
       -
                     "key": {

     

       157
       -
                       "type": "string"

     

       158
       -
                     },

     

       159
       -
                     "value": {

     

       160
       -
                       "type": "string"

     

       161
       -
                     }

     

       162
       -
                   }

     

       163
        
                 }

     

       164
        
               },

     

       165
        
               "clone": {

     
···

       168
        
               }

     

       169
        
             }

     

       170
        
           },

     

       171
       -
           "dependencies": {

     

       172
       -
             "type": "array",

     

       173
       -
             "items": {

     

       174
       -
               "type": "object",

     

       175
       -
               "required": ["registry", "packages"],

     

       176
       -
               "properties": {

     

       177
       -
                 "registry": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178
        
                   "type": "string"

     

       179
       -
                 },

     

       180
       -
                 "packages": {

     

       181
       -
                   "type": "array",

     

       182
       -
                   "items": {

     

       183
       -
                     "type": "string"

     

       184
       -
                   }

     

       185
        
                 }

     

       186
        
               }

     

       187
        
             }

     

       188
        
           },

     

       189
        
           "cloneOpts": {

     

       190
        
             "type": "object",

     

       191
       -
             "required": ["skip", "depth", "submodules"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       192
        
             "properties": {

     

       193
        
               "skip": {

     

       194
        
                 "type": "boolean"

     
···

       203
        
           },

     

       204
        
           "step": {

     

       205
        
             "type": "object",

     

       206
       -
             "required": ["name", "command"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       207
        
             "properties": {

     

       208
        
               "name": {

     

       209
        
                 "type": "string"

     
···

       214
        
               "environment": {

     

       215
        
                 "type": "array",

     

       216
        
                 "items": {

     

       217
       -
                   "type": "object",

     

       218
       -
                   "required": ["key", "value"],

     

       219
       -
                   "properties": {

     

       220
       -
                     "key": {

     

       221
       -
                       "type": "string"

     

       222
       -
                     },

     

       223
       -
                     "value": {

     

       224
       -
                       "type": "string"

     

       225
       -
                     }

     

       226
       -
                   }

     

       227
        
                 }

     

       228
        
               }

     

       229
        
             }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       230
        
           }

     

       231
        
         }

     

       232
        
       }

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "triggerMetadata",

     

       14
       +
                 "workflows"

     

       15
       +
               ],

     

       16
        
               "properties": {

     

       17
        
                 "triggerMetadata": {

     

       18
        
                   "type": "ref",

     
···

       30
        
           },

     

       31
        
           "triggerMetadata": {

     

       32
        
             "type": "object",

     

       33
       +
             "required": [

     

       34
       +
               "kind",

     

       35
       +
               "repo"

     

       36
       +
             ],

     

       37
        
             "properties": {

     

       38
        
               "kind": {

     

       39
        
                 "type": "string",

     

       40
       +
                 "enum": [

     

       41
       +
                   "push",

     

       42
       +
                   "pull_request",

     

       43
       +
                   "manual"

     

       44
       +
                 ]

     

       45
        
               },

     

       46
        
               "repo": {

     

       47
        
                 "type": "ref",

     
···

       63
        
           },

     

       64
        
           "triggerRepo": {

     

       65
        
             "type": "object",

     

       66
       +
             "required": [

     

       67
       +
               "knot",

     

       68
       +
               "did",

     

       69
       +
               "repo",

     

       70
       +
               "defaultBranch"

     

       71
       +
             ],

     

       72
        
             "properties": {

     

       73
        
               "knot": {

     

       74
        
                 "type": "string"

     
···

       87
        
           },

     

       88
        
           "pushTriggerData": {

     

       89
        
             "type": "object",

     

       90
       +
             "required": [

     

       91
       +
               "ref",

     

       92
       +
               "newSha",

     

       93
       +
               "oldSha"

     

       94
       +
             ],

     

       95
        
             "properties": {

     

       96
        
               "ref": {

     

       97
        
                 "type": "string"

     
···

       110
        
           },

     

       111
        
           "pullRequestTriggerData": {

     

       112
        
             "type": "object",

     

       113
       +
             "required": [

     

       114
       +
               "sourceBranch",

     

       115
       +
               "targetBranch",

     

       116
       +
               "sourceSha",

     

       117
       +
               "action"

     

       118
       +
             ],

     

       119
        
             "properties": {

     

       120
        
               "sourceBranch": {

     

       121
        
                 "type": "string"

     
···

       139
        
               "inputs": {

     

       140
        
                 "type": "array",

     

       141
        
                 "items": {

     

       142
       +
                   "type": "ref",

     

       143
       +
                   "ref": "#pair"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       144
        
                 }

     

       145
        
               }

     

       146
        
             }

     

       147
        
           },

     

       148
        
           "workflow": {

     

       149
        
             "type": "object",

     

       150
       +
             "required": [

     

       151
       +
               "name",

     

       152
       +
               "dependencies",

     

       153
       +
               "steps",

     

       154
       +
               "environment",

     

       155
       +
               "clone"

     

       156
       +
             ],

     

       157
        
             "properties": {

     

       158
        
               "name": {

     

       159
        
                 "type": "string"

     

       160
        
               },

     

       161
        
               "dependencies": {

     

       162
       +
                 "type": "array",

     

       163
       +
                 "items": {

     

       164
       +
                   "type": "ref",

     

       165
       +
                   "ref": "#dependency"

     

       166
       +
                 }

     

       167
        
               },

     

       168
        
               "steps": {

     

       169
        
                 "type": "array",

     
···

       175
        
               "environment": {

     

       176
        
                 "type": "array",

     

       177
        
                 "items": {

     

       178
       +
                   "type": "ref",

     

       179
       +
                   "ref": "#pair"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
                 }

     

       181
        
               },

     

       182
        
               "clone": {

     
···

       185
        
               }

     

       186
        
             }

     

       187
        
           },

     

       188
       +
           "dependency": {

     

       189
       +
             "type": "object",

     

       190
       +
             "required": [

     

       191
       +
               "registry",

     

       192
       +
               "packages"

     

       193
       +
             ],

     

       194
       +
             "properties": {

     

       195
       +
               "registry": {

     

       196
       +
                 "type": "string"

     

       197
       +
               },

     

       198
       +
               "packages": {

     

       199
       +
                 "type": "array",

     

       200
       +
                 "items": {

     

       201
        
                   "type": "string"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       202
        
                 }

     

       203
        
               }

     

       204
        
             }

     

       205
        
           },

     

       206
        
           "cloneOpts": {

     

       207
        
             "type": "object",

     

       208
       +
             "required": [

     

       209
       +
               "skip",

     

       210
       +
               "depth",

     

       211
       +
               "submodules"

     

       212
       +
             ],

     

       213
        
             "properties": {

     

       214
        
               "skip": {

     

       215
        
                 "type": "boolean"

     
···

       224
        
           },

     

       225
        
           "step": {

     

       226
        
             "type": "object",

     

       227
       +
             "required": [

     

       228
       +
               "name",

     

       229
       +
               "command"

     

       230
       +
             ],

     

       231
        
             "properties": {

     

       232
        
               "name": {

     

       233
        
                 "type": "string"

     
···

       238
        
               "environment": {

     

       239
        
                 "type": "array",

     

       240
        
                 "items": {

     

       241
       +
                   "type": "ref",

     

       242
       +
                   "ref": "#pair"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       243
        
                 }

     

       244
        
               }

     

       245
        
             }

     

       246
       +
           },

     

       247
       +
           "pair": {

     

       248
       +
             "type": "object",

     

       249
       +
             "required": [

     

       250
       +
               "key",

     

       251
       +
               "value"

     

       252
       +
             ],

     

       253
       +
             "properties": {

     

       254
       +
               "key": {

     

       255
       +
                 "type": "string"

     

       256
       +
               },

     

       257
       +
               "value": {

     

       258
       +
                 "type": "string"

     

       259
       +
               }

     

       260
       +
             }

     

       261
        
           }

     

       262
        
         }

     

       263
        
       }

+1 -1

spindle/engine/envs_test.go

···

       34
        
       			if got == nil {

     

       35
        
       				got = EnvVars{}

     

       36
        
       			}

     

       37
       -
       			assert.Equal(t, tt.want, got)

     

       38
        
       		})

     

       39
        
       	}

     

       40
        
       }

···

       34
        
       			if got == nil {

     

       35
        
       				got = EnvVars{}

     

       36
        
       			}

     

       37
       +
       			assert.ElementsMatch(t, tt.want, got)

     

       38
        
       		})

     

       39
        
       	}

     

       40
        
       }

+8 -1

docs/spindle/hosting.md

···

       36
        
           go build -o cmd/spindle/spindle cmd/spindle/main.go

     

       37
        
           ```

     

       38
        
       

     

       39
       -
       3.  **Run the Spindle binary.**

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
       

     

       41
        
           ```shell

     

       42
        
           ./cmd/spindle/spindle

···

       36
        
           go build -o cmd/spindle/spindle cmd/spindle/main.go

     

       37
        
           ```

     

       38
        
       

     

       39
       +
       3.  **Create the log directory.**

     

       40
       +
       

     

       41
       +
           ```shell

     

       42
       +
           sudo mkdir -p /var/log/spindle

     

       43
       +
           sudo chown $USER:$USER -R /var/log/spindle

     

       44
       +
           ```

     

       45
       +
       

     

       46
       +
       4.  **Run the Spindle binary.**

     

       47
        
       

     

       48
        
           ```shell

     

       49
        
           ./cmd/spindle/spindle

+24

api/tangled/feedreaction.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.feed.reaction

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	FeedReactionNSID = "sh.tangled.feed.reaction"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.feed.reaction", &FeedReaction{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: FeedReaction

     

       19
       +
       type FeedReaction struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.feed.reaction" cborgen:"$type,const=sh.tangled.feed.reaction"`

     

       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
       +
       	Reaction      string `json:"reaction" cborgen:"reaction"`

     

       23
       +
       	Subject       string `json:"subject" cborgen:"subject"`

     

       24
       +
       }

+34

lexicons/feed/reaction.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.feed.reaction",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "tid",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "reaction",

     

       15
       +
                 "createdAt"

     

       16
       +
               ],

     

       17
       +
               "properties": {

     

       18
       +
                 "subject": {

     

       19
       +
                   "type": "string",

     

       20
       +
                   "format": "at-uri"

     

       21
       +
                 },

     

       22
       +
                 "reaction": {

     

       23
       +
                   "type": "string",

     

       24
       +
                   "enum": [ "👍", "👎", "😆", "🎉", "🫤", "❤️", "🚀", "👀" ]

     

       25
       +
                 },

     

       26
       +
                 "createdAt": {

     

       27
       +
                   "type": "string",

     

       28
       +
                   "format": "datetime"

     

       29
       +
                 }

     

       30
       +
               }

     

       31
       +
             }

     

       32
       +
           }

     

       33
       +
         }

     

       34
       +
       }

-93

appview/pages/templates/knots.html

···

       1
       -
       {{ define "title" }}knots{{ end }}

     

       2
       -
       {{ define "content" }}

     

       3
       -
         <div class="p-6">

     

       4
       -
           <p class="text-xl font-bold dark:text-white">Knots</p>

     

       5
       -
         </div>

     

       6
       -
         <div class="flex flex-col">

     

       7
       -
           <h2 class="text-sm font-bold py-2 px-6 uppercase dark:text-gray-300">register a knot</h2>

     

       8
       -
           <section class="rounded bg-white dark:bg-gray-800 drop-shadow-sm px-6 py-4 mb-6 w-full lg:w-fit">

     

       9
       -
             <p class="mb-8 dark:text-gray-300">Generate a key to initialize your knot server.</p>

     

       10
       -
             <form 

     

       11
       -
               hx-post="/knots/key"

     

       12
       -
               class="max-w-2xl mb-8 space-y-4"

     

       13
       -
               hx-indicator="#generate-knot-key-spinner"

     

       14
       -
             >

     

       15
       -
               <input

     

       16
       -
                 type="text"

     

       17
       -
                 id="domain"

     

       18
       -
                 name="domain"

     

       19
       -
                 placeholder="knot.example.com"

     

       20
       -
                 required

     

       21
       -
                 class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400"

     

       22
       -
               >

     

       23
       -
               <button class="btn dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 flex items-center" type="submit">

     

       24
       -
                 <span>generate key</span>

     

       25
       -
                 <span id="generate-knot-key-spinner" class="group">

     

       26
       -
                   {{ i "loader-circle" "pl-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       27
       -
                 </span>

     

       28
       -
               </button>

     

       29
       -
               <div id="settings-knots-error" class="error dark:text-red-400"></div>

     

       30
       -
             </form>

     

       31
       -
           </section>

     

       32
       -
       

     

       33
       -
           <h2 class="text-sm font-bold py-2 px-6 uppercase dark:text-gray-300">my knots</h2>

     

       34
       -
           <section class="rounded bg-white dark:bg-gray-800 drop-shadow-sm px-6 py-4 mb-6 w-full lg:w-fit">

     

       35
       -
             <div id="knots-list" class="flex flex-col gap-6 mb-8">

     

       36
       -
               {{ range .Registrations }}

     

       37
       -
                 {{ if .Registered }}

     

       38
       -
                 <div class="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-4">

     

       39
       -
                   <div class="flex flex-col gap-1">

     

       40
       -
                     <div class="inline-flex items-center gap-4">

     

       41
       -
                       {{ i "git-branch" "w-3 h-3 dark:text-gray-300" }}

     

       42
       -
                       <a href="/knots/{{ .Domain }}">

     

       43
       -
                         <p class="font-bold dark:text-white">{{ .Domain }}</p>

     

       44
       -
                       </a>

     

       45
       -
                     </div>

     

       46
       -
                     <p class="text-sm text-gray-500 dark:text-gray-400">owned by {{ .ByDid }}</p>

     

       47
       -
                     <p class="text-sm text-gray-500 dark:text-gray-400">registered {{ template "repo/fragments/time" .Registered }}</p>

     

       48
       -
                   </div>

     

       49
       -
                 </div>

     

       50
       -
                 {{ end }}

     

       51
       -
               {{ else }}

     

       52
       -
                 <p class="text-sm text-gray-500 dark:text-gray-400">No knots registered</p>

     

       53
       -
               {{ end }}

     

       54
       -
             </div>

     

       55
       -
           </section>

     

       56
       -
       

     

       57
       -
           <h2 class="text-sm font-bold py-2 px-6 uppercase dark:text-gray-300">pending registrations</h2>

     

       58
       -
           <section class="rounded bg-white dark:bg-gray-800 drop-shadow-sm px-6 py-4 mb-6 w-full lg:w-fit">

     

       59
       -
             <div id="pending-knots-list" class="flex flex-col gap-6 mb-8">

     

       60
       -
               {{ range .Registrations }}

     

       61
       -
                 {{ if not .Registered }}

     

       62
       -
                 <div class="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-4">

     

       63
       -
                   <div class="flex flex-col gap-1">

     

       64
       -
                     <div class="inline-flex items-center gap-4">

     

       65
       -
                       <p class="font-bold dark:text-white">{{ .Domain }}</p>

     

       66
       -
                       <div class="inline-flex items-center gap-1">

     

       67
       -
                         <span class="text-xs bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 px-2 py-1 rounded">

     

       68
       -
                           pending

     

       69
       -
                         </span>

     

       70
       -
                       </div>

     

       71
       -
                     </div>

     

       72
       -
                     <p class="text-sm text-gray-500 dark:text-gray-400">opened by {{ .ByDid }}</p>

     

       73
       -
                     <p class="text-sm text-gray-500 dark:text-gray-400">created {{ template "repo/fragments/time" .Created }}</p>

     

       74
       -
                   </div>

     

       75
       -
                   <div class="flex gap-2 items-center">

     

       76
       -
                     <button

     

       77
       -
                       class="btn dark:bg-gray-700 dark:text-white dark:hover:bg-gray-600 flex gap-2 items-center group"

     

       78
       -
                       hx-post="/knots/{{ .Domain }}/init"

     

       79
       -
                     >

     

       80
       -
                       {{ i "square-play" "w-5 h-5" }}

     

       81
       -
                       <span class="hidden md:inline">initialize</span>

     

       82
       -
                       {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       83
       -
                     </button>

     

       84
       -
                   </div>

     

       85
       -
                 </div>

     

       86
       -
                 {{ end }}

     

       87
       -
               {{ else }}

     

       88
       -
                 <p class="text-sm text-gray-500 dark:text-gray-400">No pending registrations</p>

     

       89
       -
               {{ end }}

     

       90
       -
             </div>

     

       91
       -
           </section>

     

       92
       -
         </div>

     

       93
       -
       {{ end }}

+42

knotserver/git/cmd.go

···

       1
       +
       package git

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       	"os/exec"

     

       6
       +
       )

     

       7
       +
       

     

       8
       +
       const (

     

       9
       +
       	fieldSeparator  = "\x1f" // ASCII Unit Separator

     

       10
       +
       	recordSeparator = "\x1e" // ASCII Record Separator

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       func (g *GitRepo) runGitCmd(command string, extraArgs ...string) ([]byte, error) {

     

       14
       +
       	var args []string

     

       15
       +
       	args = append(args, command)

     

       16
       +
       	args = append(args, extraArgs...)

     

       17
       +
       

     

       18
       +
       	cmd := exec.Command("git", args...)

     

       19
       +
       	cmd.Dir = g.path

     

       20
       +
       

     

       21
       +
       	out, err := cmd.Output()

     

       22
       +
       	if err != nil {

     

       23
       +
       		if exitErr, ok := err.(*exec.ExitError); ok {

     

       24
       +
       			return nil, fmt.Errorf("%w, stderr: %s", err, string(exitErr.Stderr))

     

       25
       +
       		}

     

       26
       +
       		return nil, err

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	return out, nil

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       func (g *GitRepo) revList(extraArgs ...string) ([]byte, error) {

     

       33
       +
       	return g.runGitCmd("rev-list", extraArgs...)

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       func (g *GitRepo) forEachRef(extraArgs ...string) ([]byte, error) {

     

       37
       +
       	return g.runGitCmd("for-each-ref", extraArgs...)

     

       38
       +
       }

     

       39
       +
       

     

       40
       +
       func (g *GitRepo) revParse(extraArgs ...string) ([]byte, error) {

     

       41
       +
       	return g.runGitCmd("rev-parse", extraArgs...)

     

       42
       +
       }

-11

appview/tid.go

···

       1
       -
       package appview

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       5
       -
       )

     

       6
       -
       

     

       7
       -
       var c syntax.TIDClock = syntax.NewTIDClock(0)

     

       8
       -
       

     

       9
       -
       func TID() string {

     

       10
       -
       	return c.Next().String()

     

       11
       -
       }

+33 -4

avatar/src/index.js

···

       1
        
       export default {

     

       2
        
         async fetch(request, env) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
           const url = new URL(request.url);

     

       4
        
           const { pathname, searchParams } = url;

     

       5
        
       

     
···

       60
        
             const profile = await profileResponse.json();

     

       61
        
             const avatar = profile.avatar;

     

       62
        
       

     

       63
       -
             if (!avatar) {

     

       64
       -
               return new Response(`avatar not found for ${actor}.`, { status: 404 });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       65
        
             }

     

       66
        
       

     

       67
        
             // Resize if requested

     

       68
        
             let avatarResponse;

     

       69
        
             if (resizeToTiny) {

     

       70
       -
               avatarResponse = await fetch(avatar, {

     

       71
        
                 cf: {

     

       72
        
                   image: {

     

       73
        
                     width: 32,

     
···

       78
        
                 },

     

       79
        
               });

     

       80
        
             } else {

     

       81
       -
               avatarResponse = await fetch(avatar);

     

       82
        
             }

     

       83
        
       

     

       84
        
             if (!avatarResponse.ok) {

···

       1
        
       export default {

     

       2
        
         async fetch(request, env) {

     

       3
       +
           // Helper function to generate a color from a string

     

       4
       +
           const stringToColor = (str) => {

     

       5
       +
             let hash = 0;

     

       6
       +
             for (let i = 0; i < str.length; i++) {

     

       7
       +
               hash = str.charCodeAt(i) + ((hash << 5) - hash);

     

       8
       +
             }

     

       9
       +
             let color = "#";

     

       10
       +
             for (let i = 0; i < 3; i++) {

     

       11
       +
               const value = (hash >> (i * 8)) & 0xff;

     

       12
       +
               color += ("00" + value.toString(16)).substr(-2);

     

       13
       +
             }

     

       14
       +
             return color;

     

       15
       +
           };

     

       16
       +
       

     

       17
        
           const url = new URL(request.url);

     

       18
        
           const { pathname, searchParams } = url;

     

       19
        
       

     
···

       74
        
             const profile = await profileResponse.json();

     

       75
        
             const avatar = profile.avatar;

     

       76
        
       

     

       77
       +
             let avatarUrl = profile.avatar;

     

       78
       +
       

     

       79
       +
             if (!avatarUrl) {

     

       80
       +
               // Generate a random color based on the actor string

     

       81
       +
               const bgColor = stringToColor(actor);

     

       82
       +
               const size = resizeToTiny ? 32 : 128;

     

       83
       +
               const svg = `<svg width="${size}" height="${size}" viewBox="0 0 ${size} ${size}" xmlns="http://www.w3.org/2000/svg"><rect width="${size}" height="${size}" fill="${bgColor}"/></svg>`;

     

       84
       +
               const svgData = new TextEncoder().encode(svg);

     

       85
       +
       

     

       86
       +
               response = new Response(svgData, {

     

       87
       +
                 headers: {

     

       88
       +
                   "Content-Type": "image/svg+xml",

     

       89
       +
                   "Cache-Control": "public, max-age=43200",

     

       90
       +
                 },

     

       91
       +
               });

     

       92
       +
               await cache.put(cacheKey, response.clone());

     

       93
       +
               return response;

     

       94
        
             }

     

       95
        
       

     

       96
        
             // Resize if requested

     

       97
        
             let avatarResponse;

     

       98
        
             if (resizeToTiny) {

     

       99
       +
               avatarResponse = await fetch(avatarUrl, {

     

       100
        
                 cf: {

     

       101
        
                   image: {

     

       102
        
                     width: 32,

     
···

       107
        
                 },

     

       108
        
               });

     

       109
        
             } else {

     

       110
       +
               avatarResponse = await fetch(avatarUrl);

     

       111
        
             }

     

       112
        
       

     

       113
        
             if (!avatarResponse.ok) {

-48

appview/pages/templates/repo/fragments/repoActions.html

···

       1
       -
       {{ define "repo/fragments/repoActions" }}

     

       2
       -
           <div class="flex items-center gap-2 z-auto">

     

       3
       -
               <button

     

       4
       -
                   id="starBtn"

     

       5
       -
                   class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       6
       -
                   {{ if .IsStarred }}

     

       7
       -
                       hx-delete="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       8
       -
                   {{ else }}

     

       9
       -
                       hx-post="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       10
       -
                   {{ end }}

     

       11
       -
       

     

       12
       -
                   hx-trigger="click"

     

       13
       -
                   hx-target="#starBtn"

     

       14
       -
                   hx-swap="outerHTML"

     

       15
       -
                   hx-disabled-elt="#starBtn"

     

       16
       -
               >

     

       17
       -
                 {{ if .IsStarred }}

     

       18
       -
                     {{ i "star" "w-4 h-4 fill-current" }}

     

       19
       -
                 {{ else }}

     

       20
       -
                     {{ i "star" "w-4 h-4" }}

     

       21
       -
                 {{ end }}

     

       22
       -
                 <span class="text-sm">

     

       23
       -
                     {{ .Stats.StarCount }}

     

       24
       -
                 </span>

     

       25
       -
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       26
       -
               </button>

     

       27
       -
               {{ if .DisableFork }}

     

       28
       -
                   <button

     

       29
       -
                       class="btn text-sm no-underline hover:no-underline flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed"

     

       30
       -
                       disabled

     

       31
       -
                       title="Empty repositories cannot be forked"

     

       32
       -
                   >

     

       33
       -
                       {{ i "git-fork" "w-4 h-4" }}

     

       34
       -
                       fork

     

       35
       -
                   </button>

     

       36
       -
               {{ else }}

     

       37
       -
                   <a

     

       38
       -
                       class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group"

     

       39
       -
                       hx-boost="true"

     

       40
       -
                       href="/{{ .FullName }}/fork"

     

       41
       -
                   >

     

       42
       -
                       {{ i "git-fork" "w-4 h-4" }}

     

       43
       -
                       fork

     

       44
       -
                       {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       45
       -
                   </a>

     

       46
       -
               {{ end }}

     

       47
       -
           </div>

     

       48
       -
       {{ end }}

+3 -1

api/tangled/stateclosed.go

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.issue.state.closed

     

       6
        
       

     

       7
       -
       const ()

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       const RepoIssueStateClosed = "sh.tangled.repo.issue.state.closed"

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.issue.state.closed

     

       6
        
       

     

       7
       +
       const (

     

       8
       +
       	RepoIssueStateClosedNSID = "sh.tangled.repo.issue.state.closed"

     

       9
       +
       )

     

       10
        
       

     

       11
        
       const RepoIssueStateClosed = "sh.tangled.repo.issue.state.closed"

+3 -1

api/tangled/stateopen.go

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.issue.state.open

     

       6
        
       

     

       7
       -
       const ()

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       const RepoIssueStateOpen = "sh.tangled.repo.issue.state.open"

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.issue.state.open

     

       6
        
       

     

       7
       +
       const (

     

       8
       +
       	RepoIssueStateOpenNSID = "sh.tangled.repo.issue.state.open"

     

       9
       +
       )

     

       10
        
       

     

       11
        
       const RepoIssueStateOpen = "sh.tangled.repo.issue.state.open"

+3 -1

api/tangled/statusclosed.go

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.closed

     

       6
        
       

     

       7
       -
       const ()

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       const RepoPullStatusClosed = "sh.tangled.repo.pull.status.closed"

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.closed

     

       6
        
       

     

       7
       +
       const (

     

       8
       +
       	RepoPullStatusClosedNSID = "sh.tangled.repo.pull.status.closed"

     

       9
       +
       )

     

       10
        
       

     

       11
        
       const RepoPullStatusClosed = "sh.tangled.repo.pull.status.closed"

+3 -1

api/tangled/statusmerged.go

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.merged

     

       6
        
       

     

       7
       -
       const ()

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       const RepoPullStatusMerged = "sh.tangled.repo.pull.status.merged"

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.merged

     

       6
        
       

     

       7
       +
       const (

     

       8
       +
       	RepoPullStatusMergedNSID = "sh.tangled.repo.pull.status.merged"

     

       9
       +
       )

     

       10
        
       

     

       11
        
       const RepoPullStatusMerged = "sh.tangled.repo.pull.status.merged"

+3 -1

api/tangled/statusopen.go

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.open

     

       6
        
       

     

       7
       -
       const ()

     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
        
       const RepoPullStatusOpen = "sh.tangled.repo.pull.status.open"

···

       4
        
       

     

       5
        
       // schema: sh.tangled.repo.pull.status.open

     

       6
        
       

     

       7
       +
       const (

     

       8
       +
       	RepoPullStatusOpenNSID = "sh.tangled.repo.pull.status.open"

     

       9
       +
       )

     

       10
        
       

     

       11
        
       const RepoPullStatusOpen = "sh.tangled.repo.pull.status.open"

appview/idresolver/resolver.go

···

       111
        
       

     

       112
        
       	return r.directory.Purge(ctx, *id)

     

       113
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       111
        
       

     

       112
        
       	return r.directory.Purge(ctx, *id)

     

       113
        
       }

     

       114
       +
       

     

       115
       +
       func (r *Resolver) Directory() identity.Directory {

     

       116
       +
       	return r.directory

     

       117
       +
       }

+2 -3

appview/idresolver/resolver.go idresolver/resolver.go

···

       11
        
       	"github.com/bluesky-social/indigo/atproto/identity/redisdir"

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
        
       	"github.com/carlmjohnson/versioninfo"

     

       14
       -
       	"tangled.sh/tangled.sh/core/appview/config"

     

       15
        
       )

     

       16
        
       

     

       17
        
       type Resolver struct {

     
···

       56
        
       	}

     

       57
        
       }

     

       58
        
       

     

       59
       -
       func RedisResolver(config config.RedisConfig) (*Resolver, error) {

     

       60
       -
       	directory, err := RedisDirectory(config.ToURL())

     

       61
        
       	if err != nil {

     

       62
        
       		return nil, err

     

       63
        
       	}

···

       11
        
       	"github.com/bluesky-social/indigo/atproto/identity/redisdir"

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
        
       	"github.com/carlmjohnson/versioninfo"

     

       0
        
       
     

       14
        
       )

     

       15
        
       

     

       16
        
       type Resolver struct {

     
···

       55
        
       	}

     

       56
        
       }

     

       57
        
       

     

       58
       +
       func RedisResolver(redisUrl string) (*Resolver, error) {

     

       59
       +
       	directory, err := RedisDirectory(redisUrl)

     

       60
        
       	if err != nil {

     

       61
        
       		return nil, err

     

       62
        
       	}

+30

api/tangled/reposetDefaultBranch.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.setDefaultBranch

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoSetDefaultBranchNSID = "sh.tangled.repo.setDefaultBranch"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoSetDefaultBranch_Input is the input argument to a sh.tangled.repo.setDefaultBranch call.

     

       18
       +
       type RepoSetDefaultBranch_Input struct {

     

       19
       +
       	DefaultBranch string `json:"defaultBranch" cborgen:"defaultBranch"`

     

       20
       +
       	Repo          string `json:"repo" cborgen:"repo"`

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       // RepoSetDefaultBranch calls the XRPC method "sh.tangled.repo.setDefaultBranch".

     

       24
       +
       func RepoSetDefaultBranch(ctx context.Context, c util.LexClient, input *RepoSetDefaultBranch_Input) error {

     

       25
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.setDefaultBranch", nil, input, nil); err != nil {

     

       26
       +
       		return err

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	return nil

     

       30
       +
       }

+29

lexicons/defaultBranch.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.setDefaultBranch",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Set the default branch for a repository",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "repo",

     

       14
       +
                   "defaultBranch"

     

       15
       +
                 ],

     

       16
       +
                 "properties": {

     

       17
       +
                   "repo": {

     

       18
       +
                     "type": "string",

     

       19
       +
                     "format": "at-uri"

     

       20
       +
                   },

     

       21
       +
                   "defaultBranch": {

     

       22
       +
                     "type": "string"

     

       23
       +
                   }

     

       24
       +
                 }

     

       25
       +
               }

     

       26
       +
             }

     

       27
       +
           }

     

       28
       +
         }

     

       29
       +
       }

+6 -1

hook/setup.go

···

       133
        
       

     

       134
        
       	hookContent := fmt.Sprintf(`#!/usr/bin/env bash

     

       135
        
       # AUTO GENERATED BY KNOT, DO NOT MODIFY

     

       136
       -
       %s hook -git-dir "$GIT_DIR" -user-did "$GIT_USER_DID" -user-handle "$GIT_USER_HANDLE" -internal-api "%s" post-recieve

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       137
        
       	`, executablePath, config.internalApi)

     

       138
        
       

     

       139
        
       	return os.WriteFile(hookPath, []byte(hookContent), 0755)

···

       133
        
       

     

       134
        
       	hookContent := fmt.Sprintf(`#!/usr/bin/env bash

     

       135
        
       # AUTO GENERATED BY KNOT, DO NOT MODIFY

     

       136
       +
       push_options=()

     

       137
       +
       for ((i=0; i<GIT_PUSH_OPTION_COUNT; i++)); do

     

       138
       +
           option_var="GIT_PUSH_OPTION_$i"

     

       139
       +
           push_options+=(-push-option "${!option_var}")

     

       140
       +
       done

     

       141
       +
       %s hook -git-dir "$GIT_DIR" -user-did "$GIT_USER_DID" -user-handle "$GIT_USER_HANDLE" -internal-api "%s" "${push_options[@]}" post-recieve

     

       142
        
       	`, executablePath, config.internalApi)

     

       143
        
       

     

       144
        
       	return os.WriteFile(hookPath, []byte(hookContent), 0755)

+14

hook/hook.go

···

       3
        
       import (

     

       4
        
       	"bufio"

     

       5
        
       	"context"

     

       0
        
       
     

       6
        
       	"fmt"

     

       7
        
       	"net/http"

     

       8
        
       	"os"

     
···

       11
        
       	"github.com/urfave/cli/v3"

     

       12
        
       )

     

       13
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       // The hook command is nested like so:

     

       15
        
       //

     

       16
        
       //	knot hook --[flags] [hook]

     
···

       88
        
       		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)

     

       89
        
       	}

     

       90
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       91
        
       	return nil

     

       92
        
       }

···

       3
        
       import (

     

       4
        
       	"bufio"

     

       5
        
       	"context"

     

       6
       +
       	"encoding/json"

     

       7
        
       	"fmt"

     

       8
        
       	"net/http"

     

       9
        
       	"os"

     
···

       12
        
       	"github.com/urfave/cli/v3"

     

       13
        
       )

     

       14
        
       

     

       15
       +
       type HookResponse struct {

     

       16
       +
       	Messages []string `json:"messages"`

     

       17
       +
       }

     

       18
       +
       

     

       19
        
       // The hook command is nested like so:

     

       20
        
       //

     

       21
        
       //	knot hook --[flags] [hook]

     
···

       93
        
       		return fmt.Errorf("unexpected status code: %d", resp.StatusCode)

     

       94
        
       	}

     

       95
        
       

     

       96
       +
       	var data HookResponse

     

       97
       +
       	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {

     

       98
       +
       		return fmt.Errorf("failed to decode response: %w", err)

     

       99
       +
       	}

     

       100
       +
       

     

       101
       +
       	for _, message := range data.Messages {

     

       102
       +
       		fmt.Println(message)

     

       103
       +
       	}

     

       104
       +
       

     

       105
        
       	return nil

     

       106
        
       }

+31

api/tangled/repoaddSecret.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.addSecret

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoAddSecretNSID = "sh.tangled.repo.addSecret"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoAddSecret_Input is the input argument to a sh.tangled.repo.addSecret call.

     

       18
       +
       type RepoAddSecret_Input struct {

     

       19
       +
       	Key   string `json:"key" cborgen:"key"`

     

       20
       +
       	Repo  string `json:"repo" cborgen:"repo"`

     

       21
       +
       	Value string `json:"value" cborgen:"value"`

     

       22
       +
       }

     

       23
       +
       

     

       24
       +
       // RepoAddSecret calls the XRPC method "sh.tangled.repo.addSecret".

     

       25
       +
       func RepoAddSecret(ctx context.Context, c util.LexClient, input *RepoAddSecret_Input) error {

     

       26
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.addSecret", nil, input, nil); err != nil {

     

       27
       +
       		return err

     

       28
       +
       	}

     

       29
       +
       

     

       30
       +
       	return nil

     

       31
       +
       }

+41

api/tangled/repolistSecrets.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.listSecrets

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoListSecretsNSID = "sh.tangled.repo.listSecrets"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoListSecrets_Output is the output of a sh.tangled.repo.listSecrets call.

     

       18
       +
       type RepoListSecrets_Output struct {

     

       19
       +
       	Secrets []*RepoListSecrets_Secret `json:"secrets" cborgen:"secrets"`

     

       20
       +
       }

     

       21
       +
       

     

       22
       +
       // RepoListSecrets_Secret is a "secret" in the sh.tangled.repo.listSecrets schema.

     

       23
       +
       type RepoListSecrets_Secret struct {

     

       24
       +
       	CreatedAt string `json:"createdAt" cborgen:"createdAt"`

     

       25
       +
       	CreatedBy string `json:"createdBy" cborgen:"createdBy"`

     

       26
       +
       	Key       string `json:"key" cborgen:"key"`

     

       27
       +
       	Repo      string `json:"repo" cborgen:"repo"`

     

       28
       +
       }

     

       29
       +
       

     

       30
       +
       // RepoListSecrets calls the XRPC method "sh.tangled.repo.listSecrets".

     

       31
       +
       func RepoListSecrets(ctx context.Context, c util.LexClient, repo string) (*RepoListSecrets_Output, error) {

     

       32
       +
       	var out RepoListSecrets_Output

     

       33
       +
       

     

       34
       +
       	params := map[string]interface{}{}

     

       35
       +
       	params["repo"] = repo

     

       36
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.listSecrets", params, nil, &out); err != nil {

     

       37
       +
       		return nil, err

     

       38
       +
       	}

     

       39
       +
       

     

       40
       +
       	return &out, nil

     

       41
       +
       }

+30

api/tangled/reporemoveSecret.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.removeSecret

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoRemoveSecretNSID = "sh.tangled.repo.removeSecret"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoRemoveSecret_Input is the input argument to a sh.tangled.repo.removeSecret call.

     

       18
       +
       type RepoRemoveSecret_Input struct {

     

       19
       +
       	Key  string `json:"key" cborgen:"key"`

     

       20
       +
       	Repo string `json:"repo" cborgen:"repo"`

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       // RepoRemoveSecret calls the XRPC method "sh.tangled.repo.removeSecret".

     

       24
       +
       func RepoRemoveSecret(ctx context.Context, c util.LexClient, input *RepoRemoveSecret_Input) error {

     

       25
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.removeSecret", nil, input, nil); err != nil {

     

       26
       +
       		return err

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	return nil

     

       30
       +
       }

+37

lexicons/addSecret.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.addSecret",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Add a CI secret",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "repo",

     

       14
       +
                   "key",

     

       15
       +
                   "value"

     

       16
       +
                 ],

     

       17
       +
                 "properties": {

     

       18
       +
                   "repo": {

     

       19
       +
                     "type": "string",

     

       20
       +
                     "format": "at-uri"

     

       21
       +
                   },

     

       22
       +
                   "key": {

     

       23
       +
                     "type": "string",

     

       24
       +
                     "maxLength": 50,

     

       25
       +
                     "minLength": 1

     

       26
       +
                   },

     

       27
       +
                   "value": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "maxLength": 200,

     

       30
       +
                     "minLength": 1

     

       31
       +
                   }

     

       32
       +
                 }

     

       33
       +
               }

     

       34
       +
             }

     

       35
       +
           }

     

       36
       +
         }

     

       37
       +
       }

+67

lexicons/listSecrets.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.listSecrets",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": [

     

       10
       +
                 "repo"

     

       11
       +
               ],

     

       12
       +
               "properties": {

     

       13
       +
                 "repo": {

     

       14
       +
                   "type": "string",

     

       15
       +
                   "format": "at-uri"

     

       16
       +
                 }

     

       17
       +
               }

     

       18
       +
             },

     

       19
       +
             "output": {

     

       20
       +
               "encoding": "application/json",

     

       21
       +
               "schema": {

     

       22
       +
                 "type": "object",

     

       23
       +
                 "required": [

     

       24
       +
                   "secrets"

     

       25
       +
                 ],

     

       26
       +
                 "properties": {

     

       27
       +
                   "secrets": {

     

       28
       +
                     "type": "array",

     

       29
       +
                     "items": {

     

       30
       +
                       "type": "ref",

     

       31
       +
                       "ref": "#secret"

     

       32
       +
                     }

     

       33
       +
                   }

     

       34
       +
                 }

     

       35
       +
               }

     

       36
       +
             }

     

       37
       +
           },

     

       38
       +
           "secret": {

     

       39
       +
             "type": "object",

     

       40
       +
             "required": [

     

       41
       +
               "repo",

     

       42
       +
               "key",

     

       43
       +
               "createdAt",

     

       44
       +
               "createdBy"

     

       45
       +
             ],

     

       46
       +
             "properties": {

     

       47
       +
               "repo": {

     

       48
       +
                 "type": "string",

     

       49
       +
                 "format": "at-uri"

     

       50
       +
               },

     

       51
       +
               "key": {

     

       52
       +
                 "type": "string",

     

       53
       +
                 "maxLength": 50,

     

       54
       +
                 "minLength": 1

     

       55
       +
               },

     

       56
       +
               "createdAt": {

     

       57
       +
                 "type": "string",

     

       58
       +
                 "format": "datetime"

     

       59
       +
               },

     

       60
       +
               "createdBy": {

     

       61
       +
                 "type": "string",

     

       62
       +
                 "format": "did"

     

       63
       +
               }

     

       64
       +
             }

     

       65
       +
           }

     

       66
       +
         }

     

       67
       +
       }

+31

lexicons/removeSecret.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.removeSecret",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Remove a CI secret",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "repo",

     

       14
       +
                   "key"

     

       15
       +
                 ],

     

       16
       +
                 "properties": {

     

       17
       +
                   "repo": {

     

       18
       +
                     "type": "string",

     

       19
       +
                     "format": "at-uri"

     

       20
       +
                   },

     

       21
       +
                   "key": {

     

       22
       +
                     "type": "string",

     

       23
       +
                     "maxLength": 50,

     

       24
       +
                     "minLength": 1

     

       25
       +
                   }

     

       26
       +
                 }

     

       27
       +
               }

     

       28
       +
             }

     

       29
       +
           }

     

       30
       +
         }

     

       31
       +
       }

+25

spindle/motd

···

       1
       +
                           ****

     

       2
       +
                      ***        ***

     

       3
       +
                   *** **   ******   **

     

       4
       +
                  **    *           *****

     

       5
       +
                 *      **              **

     

       6
       +
                *   *    *  ***************

     

       7
       +
               **   **    *#             **

     

       8
       +
               *     **    **    ***      **

     

       9
       +
               *  *   **    **    *   ******

     

       10
       +
               *  **   **   *    **   *   *

     

       11
       +
               **  **    ***    **   **   *

     

       12
       +
                **  **    *    **    *   *

     

       13
       +
                 **   ****    **    *   *

     

       14
       +
                  **  ***    **   **  **

     

       15
       +
                    ***    **    *****

     

       16
       +
                       ********************

     

       17
       +
                                           **

     

       18
       +
                                            *

     

       19
       +
                             #**************

     

       20
       +
                             **

     

       21
       +
                               ********

     

       22
       +
       

     

       23
       +
       This is a spindle server. More info at https://tangled.sh/@tangled.sh/core/tree/master/docs/spindle

     

       24
       +
       

     

       25
       +
       Most API routes are under /xrpc/

+104

appview/signup/requests.go

···

       1
       +
       package signup

     

       2
       +
       

     

       3
       +
       // We have this extra code here for now since the xrpcclient package

     

       4
       +
       // only supports OAuth'd requests; these are unauthenticated or use PDS admin auth.

     

       5
       +
       

     

       6
       +
       import (

     

       7
       +
       	"bytes"

     

       8
       +
       	"encoding/json"

     

       9
       +
       	"fmt"

     

       10
       +
       	"io"

     

       11
       +
       	"net/http"

     

       12
       +
       	"net/url"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       // makePdsRequest is a helper method to make requests to the PDS service

     

       16
       +
       func (s *Signup) makePdsRequest(method, endpoint string, body interface{}, useAuth bool) (*http.Response, error) {

     

       17
       +
       	jsonData, err := json.Marshal(body)

     

       18
       +
       	if err != nil {

     

       19
       +
       		return nil, err

     

       20
       +
       	}

     

       21
       +
       

     

       22
       +
       	url := fmt.Sprintf("%s/xrpc/%s", s.config.Pds.Host, endpoint)

     

       23
       +
       	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonData))

     

       24
       +
       	if err != nil {

     

       25
       +
       		return nil, err

     

       26
       +
       	}

     

       27
       +
       

     

       28
       +
       	req.Header.Set("Content-Type", "application/json")

     

       29
       +
       

     

       30
       +
       	if useAuth {

     

       31
       +
       		req.SetBasicAuth("admin", s.config.Pds.AdminSecret)

     

       32
       +
       	}

     

       33
       +
       

     

       34
       +
       	return http.DefaultClient.Do(req)

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       // handlePdsError processes error responses from the PDS service

     

       38
       +
       func (s *Signup) handlePdsError(resp *http.Response, action string) error {

     

       39
       +
       	var errorResp struct {

     

       40
       +
       		Error   string `json:"error"`

     

       41
       +
       		Message string `json:"message"`

     

       42
       +
       	}

     

       43
       +
       

     

       44
       +
       	respBody, _ := io.ReadAll(resp.Body)

     

       45
       +
       	if err := json.Unmarshal(respBody, &errorResp); err == nil && errorResp.Message != "" {

     

       46
       +
       		return fmt.Errorf("Failed to %s: %s - %s.", action, errorResp.Error, errorResp.Message)

     

       47
       +
       	}

     

       48
       +
       

     

       49
       +
       	// Fallback if we couldn't parse the error

     

       50
       +
       	return fmt.Errorf("failed to %s, status code: %d", action, resp.StatusCode)

     

       51
       +
       }

     

       52
       +
       

     

       53
       +
       func (s *Signup) inviteCodeRequest() (string, error) {

     

       54
       +
       	body := map[string]any{"useCount": 1}

     

       55
       +
       

     

       56
       +
       	resp, err := s.makePdsRequest("POST", "com.atproto.server.createInviteCode", body, true)

     

       57
       +
       	if err != nil {

     

       58
       +
       		return "", err

     

       59
       +
       	}

     

       60
       +
       	defer resp.Body.Close()

     

       61
       +
       

     

       62
       +
       	if resp.StatusCode != http.StatusOK {

     

       63
       +
       		return "", s.handlePdsError(resp, "create invite code")

     

       64
       +
       	}

     

       65
       +
       

     

       66
       +
       	var result map[string]string

     

       67
       +
       	json.NewDecoder(resp.Body).Decode(&result)

     

       68
       +
       	return result["code"], nil

     

       69
       +
       }

     

       70
       +
       

     

       71
       +
       func (s *Signup) createAccountRequest(username, password, email, code string) (string, error) {

     

       72
       +
       	parsedURL, err := url.Parse(s.config.Pds.Host)

     

       73
       +
       	if err != nil {

     

       74
       +
       		return "", fmt.Errorf("invalid PDS host URL: %w", err)

     

       75
       +
       	}

     

       76
       +
       

     

       77
       +
       	pdsDomain := parsedURL.Hostname()

     

       78
       +
       

     

       79
       +
       	body := map[string]string{

     

       80
       +
       		"email":      email,

     

       81
       +
       		"handle":     fmt.Sprintf("%s.%s", username, pdsDomain),

     

       82
       +
       		"password":   password,

     

       83
       +
       		"inviteCode": code,

     

       84
       +
       	}

     

       85
       +
       

     

       86
       +
       	resp, err := s.makePdsRequest("POST", "com.atproto.server.createAccount", body, false)

     

       87
       +
       	if err != nil {

     

       88
       +
       		return "", err

     

       89
       +
       	}

     

       90
       +
       	defer resp.Body.Close()

     

       91
       +
       

     

       92
       +
       	if resp.StatusCode != http.StatusOK {

     

       93
       +
       		return "", s.handlePdsError(resp, "create account")

     

       94
       +
       	}

     

       95
       +
       

     

       96
       +
       	var result struct {

     

       97
       +
       		DID string `json:"did"`

     

       98
       +
       	}

     

       99
       +
       	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {

     

       100
       +
       		return "", fmt.Errorf("failed to decode create account response: %w", err)

     

       101
       +
       	}

     

       102
       +
       

     

       103
       +
       	return result.DID, nil

     

       104
       +
       }

lexicons/addSecret.json lexicons/repo/addSecret.json

lexicons/artifact.json lexicons/repo/artifact.json

lexicons/defaultBranch.json lexicons/repo/defaultBranch.json

lexicons/listSecrets.json lexicons/repo/listSecrets.json

lexicons/removeSecret.json lexicons/repo/removeSecret.json

lexicons/spindle.json lexicons/spindle/spindle.json

+25

api/tangled/repocollaborator.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.collaborator

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	RepoCollaboratorNSID = "sh.tangled.repo.collaborator"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.repo.collaborator", &RepoCollaborator{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: RepoCollaborator

     

       19
       +
       type RepoCollaborator struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"`

     

       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
       +
       	// repo: repo to add this user to

     

       23
       +
       	Repo    string `json:"repo" cborgen:"repo"`

     

       24
       +
       	Subject string `json:"subject" cborgen:"subject"`

     

       25
       +
       }

+36

lexicons/repo/collaborator.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.collaborator",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "tid",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "repo",

     

       15
       +
                 "createdAt"

     

       16
       +
               ],

     

       17
       +
               "properties": {

     

       18
       +
                 "subject": {

     

       19
       +
                   "type": "string",

     

       20
       +
                   "format": "did"

     

       21
       +
                 },

     

       22
       +
                 "repo": {

     

       23
       +
                   "type": "string",

     

       24
       +
                   "description": "repo to add this user to",

     

       25
       +
                   "format": "at-uri"

     

       26
       +
                 },

     

       27
       +
                 "createdAt": {

     

       28
       +
                   "type": "string",

     

       29
       +
                   "format": "datetime"

     

       30
       +
                 }

     

       31
       +
               }

     

       32
       +
             }

     

       33
       +
           }

     

       34
       +
         }

     

       35
       +
       }

     

       36
       +

+25

api/tangled/tangledstring.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.string

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	StringNSID = "sh.tangled.string"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.string", &String{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: String

     

       19
       +
       type String struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.string" cborgen:"$type,const=sh.tangled.string"`

     

       21
       +
       	Contents      string `json:"contents" cborgen:"contents"`

     

       22
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       23
       +
       	Description   string `json:"description" cborgen:"description"`

     

       24
       +
       	Filename      string `json:"filename" cborgen:"filename"`

     

       25
       +
       }

+40

lexicons/string/string.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.string",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "tid",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "filename",

     

       14
       +
                 "description",

     

       15
       +
                 "createdAt",

     

       16
       +
                 "contents"

     

       17
       +
               ],

     

       18
       +
               "properties": {

     

       19
       +
                 "filename": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "maxGraphemes": 140,

     

       22
       +
                   "minGraphemes": 1

     

       23
       +
                 },

     

       24
       +
                 "description": {

     

       25
       +
                   "type": "string",

     

       26
       +
                   "maxGraphemes": 280

     

       27
       +
                 },

     

       28
       +
                 "createdAt": {

     

       29
       +
                   "type": "string",

     

       30
       +
                   "format": "datetime"

     

       31
       +
                 },

     

       32
       +
                 "contents": {

     

       33
       +
                   "type": "string",

     

       34
       +
                   "minGraphemes": 1

     

       35
       +
                 }

     

       36
       +
               }

     

       37
       +
             }

     

       38
       +
           }

     

       39
       +
         }

     

       40
       +
       }

+2 -3

nix/pkgs/spindle.nix

···

       2
        
         buildGoApplication,

     

       3
        
         modules,

     

       4
        
         sqlite-lib,

     

       5
       -
         gitignoreSource,

     

       6
        
       }:

     

       7
        
       buildGoApplication {

     

       8
        
         pname = "spindle";

     

       9
        
         version = "0.1.0";

     

       10
       -
         src = gitignoreSource ../..;

     

       11
       -
         inherit modules;

     

       12
        
       

     

       13
        
         doCheck = false;

     

       14

···

       2
        
         buildGoApplication,

     

       3
        
         modules,

     

       4
        
         sqlite-lib,

     

       5
       +
         src,

     

       6
        
       }:

     

       7
        
       buildGoApplication {

     

       8
        
         pname = "spindle";

     

       9
        
         version = "0.1.0";

     

       10
       +
         inherit src modules;

     

       0
        
       
     

       11
        
       

     

       12
        
         doCheck = false;

     

       13

+59

spindle/db/member.go

···

       1
       +
       package db

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type SpindleMember struct {

     

       10
       +
       	Id       int

     

       11
       +
       	Did      syntax.DID // owner of the record

     

       12
       +
       	Rkey     string     // rkey of the record

     

       13
       +
       	Instance string

     

       14
       +
       	Subject  syntax.DID // the member being added

     

       15
       +
       	Created  time.Time

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       func AddSpindleMember(db *DB, member SpindleMember) error {

     

       19
       +
       	_, err := db.Exec(

     

       20
       +
       		`insert or ignore into spindle_members (did, rkey, instance, subject) values (?, ?, ?, ?)`,

     

       21
       +
       		member.Did,

     

       22
       +
       		member.Rkey,

     

       23
       +
       		member.Instance,

     

       24
       +
       		member.Subject,

     

       25
       +
       	)

     

       26
       +
       	return err

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       func RemoveSpindleMember(db *DB, owner_did, rkey string) error {

     

       30
       +
       	_, err := db.Exec(

     

       31
       +
       		"delete from spindle_members where did = ? and rkey = ?",

     

       32
       +
       		owner_did,

     

       33
       +
       		rkey,

     

       34
       +
       	)

     

       35
       +
       	return err

     

       36
       +
       }

     

       37
       +
       

     

       38
       +
       func GetSpindleMember(db *DB, did, rkey string) (*SpindleMember, error) {

     

       39
       +
       	query :=

     

       40
       +
       		`select id, did, rkey, instance, subject, created

     

       41
       +
       		from spindle_members

     

       42
       +
       		where did = ? and rkey = ?`

     

       43
       +
       

     

       44
       +
       	var member SpindleMember

     

       45
       +
       	var createdAt string

     

       46
       +
       	err := db.QueryRow(query, did, rkey).Scan(

     

       47
       +
       		&member.Id,

     

       48
       +
       		&member.Did,

     

       49
       +
       		&member.Rkey,

     

       50
       +
       		&member.Instance,

     

       51
       +
       		&member.Subject,

     

       52
       +
       		&createdAt,

     

       53
       +
       	)

     

       54
       +
       	if err != nil {

     

       55
       +
       		return nil, err

     

       56
       +
       	}

     

       57
       +
       

     

       58
       +
       	return &member, nil

     

       59
       +
       }

+1 -1

spindle/secrets/openbao.go

···

       132
        
       		return ErrKeyNotFound

     

       133
        
       	}

     

       134
        
       

     

       135
       -
       	err = v.client.KVv2(v.mountPath).Delete(ctx, secretPath)

     

       136
        
       	if err != nil {

     

       137
        
       		return fmt.Errorf("failed to delete secret from openbao: %w", err)

     

       138
        
       	}

···

       132
        
       		return ErrKeyNotFound

     

       133
        
       	}

     

       134
        
       

     

       135
       +
       	err = v.client.KVv2(v.mountPath).DeleteMetadata(ctx, secretPath)

     

       136
        
       	if err != nil {

     

       137
        
       		return fmt.Errorf("failed to delete secret from openbao: %w", err)

     

       138
        
       	}

-168

appview/pages/templates/repo/settings.html

···

       1
       -
       {{ define "title" }}settings &middot; {{ .RepoInfo.FullName }}{{ end }}

     

       2
       -
       

     

       3
       -
       {{ define "repoContent" }}

     

       4
       -
         {{ template "collaboratorSettings" . }}

     

       5
       -
         {{ template "branchSettings" . }}

     

       6
       -
         {{ template "dangerZone" . }}

     

       7
       -
         {{ template "spindleSelector" . }}

     

       8
       -
         {{ template "spindleSecrets" . }}

     

       9
       -
       {{ end }}

     

       10
       -
       

     

       11
       -
       {{ define "collaboratorSettings" }}

     

       12
       -
         <header class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       13
       -
           Collaborators

     

       14
       -
         </header>

     

       15
       -
       

     

       16
       -
         <div id="collaborator-list" class="flex flex-col gap-2 mb-2">

     

       17
       -
           {{ range .Collaborators }}

     

       18
       -
           <div id="collaborator" class="mb-2">

     

       19
       -
             <a

     

       20
       -
               href="/{{ didOrHandle .Did .Handle }}"

     

       21
       -
               class="no-underline hover:underline text-black dark:text-white"

     

       22
       -
               >

     

       23
       -
               {{ didOrHandle .Did .Handle }}

     

       24
       -
             </a>

     

       25
       -
               <div>

     

       26
       -
                 <span class="text-sm text-gray-500 dark:text-gray-400">

     

       27
       -
                   {{ .Role }}

     

       28
       -
                 </span>

     

       29
       -
               </div>

     

       30
       -
           </div>

     

       31
       -
           {{ end }}

     

       32
       -
         </div>

     

       33
       -
       

     

       34
       -
         {{ if .RepoInfo.Roles.CollaboratorInviteAllowed }}

     

       35
       -
           <form

     

       36
       -
             hx-put="/{{ $.RepoInfo.FullName }}/settings/collaborator"

     

       37
       -
             class="group"

     

       38
       -
           >

     

       39
       -
             <label for="collaborator" class="dark:text-white">

     

       40
       -
               add collaborator

     

       41
       -
             </label>

     

       42
       -
             <input

     

       43
       -
               type="text"

     

       44
       -
               id="collaborator"

     

       45
       -
               name="collaborator"

     

       46
       -
               required

     

       47
       -
               class="dark:bg-gray-700 dark:text-white"

     

       48
       -
               placeholder="enter did or handle">

     

       49
       -
             <button class="btn my-2 flex gap-2 items-center dark:text-white dark:hover:bg-gray-700" type="text">

     

       50
       -
               <span>add</span>

     

       51
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       52
       -
             </button>

     

       53
       -
           </form>

     

       54
       -
         {{ end }}

     

       55
       -
       {{ end }}

     

       56
       -
       

     

       57
       -
       {{ define "dangerZone" }}

     

       58
       -
         {{ if .RepoInfo.Roles.RepoDeleteAllowed }}

     

       59
       -
           <form

     

       60
       -
               hx-confirm="Are you sure you want to delete this repository?"

     

       61
       -
               hx-delete="/{{ $.RepoInfo.FullName }}/settings/delete"

     

       62
       -
               class="mt-6"

     

       63
       -
             hx-indicator="#delete-repo-spinner">

     

       64
       -
             <label for="branch">delete repository</label>

     

       65
       -
             <button class="btn my-2 flex items-center" type="text">

     

       66
       -
                 <span>delete</span>

     

       67
       -
                 <span id="delete-repo-spinner" class="group">

     

       68
       -
                   {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       69
       -
                 </span>

     

       70
       -
             </button>

     

       71
       -
             <span>

     

       72
       -
               Deleting a repository is irreversible and permanent.

     

       73
       -
             </span>

     

       74
       -
           </form>

     

       75
       -
         {{ end }}

     

       76
       -
       {{ end }}

     

       77
       -
       

     

       78
       -
       {{ define "branchSettings" }}

     

       79
       -
         <form hx-put="/{{ $.RepoInfo.FullName }}/settings/branches/default" class="mt-6 group">

     

       80
       -
           <label for="branch">default branch</label>

     

       81
       -
           <div class="flex gap-2 items-center">

     

       82
       -
             <select id="branch" name="branch" required class="p-1 border border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">

     

       83
       -
               <option value="" disabled selected >

     

       84
       -
                 Choose a default branch

     

       85
       -
               </option>

     

       86
       -
               {{ range .Branches }}

     

       87
       -
                 <option value="{{ .Name }}" class="py-1" {{ if .IsDefault }}selected{{ end }} >

     

       88
       -
                   {{ .Name }}

     

       89
       -
                 </option>

     

       90
       -
               {{ end }}

     

       91
       -
             </select>

     

       92
       -
             <button class="btn my-2 flex gap-2 items-center" type="submit">

     

       93
       -
               <span>save</span>

     

       94
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       95
       -
             </button>

     

       96
       -
           </div>

     

       97
       -
         </form>

     

       98
       -
       {{ end }}

     

       99
       -
       

     

       100
       -
       {{ define "spindleSelector" }}

     

       101
       -
         {{ if .RepoInfo.Roles.IsOwner }}

     

       102
       -
         <form hx-post="/{{ $.RepoInfo.FullName }}/settings/spindle" class="mt-6 group" >

     

       103
       -
           <label for="spindle">spindle</label>

     

       104
       -
           <div class="flex gap-2 items-center">

     

       105
       -
             <select id="spindle" name="spindle" required class="p-1 border border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">

     

       106
       -
               <option value="" selected >

     

       107
       -
                 None

     

       108
       -
               </option>

     

       109
       -
               {{ range .Spindles }}

     

       110
       -
                 <option value="{{ . }}" class="py-1" {{ if eq . $.CurrentSpindle }}selected{{ end }}>

     

       111
       -
                   {{ . }}

     

       112
       -
                 </option>

     

       113
       -
               {{ end }}

     

       114
       -
             </select>

     

       115
       -
             <button class="btn my-2 flex gap-2 items-center" type="submit">

     

       116
       -
               <span>save</span>

     

       117
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       118
       -
             </button>

     

       119
       -
           </div>

     

       120
       -
         </form>

     

       121
       -
         {{ end }}

     

       122
       -
       {{ end }}

     

       123
       -
       

     

       124
       -
       {{ define "spindleSecrets" }}

     

       125
       -
         {{ if $.CurrentSpindle }}

     

       126
       -
           <header class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       127
       -
             Secrets

     

       128
       -
           </header>

     

       129
       -
       

     

       130
       -
           <div id="secret-list" class="flex flex-col gap-2 mb-2">

     

       131
       -
             {{ range $idx, $secret := .Secrets }}

     

       132
       -
              {{ with $secret }}

     

       133
       -
                <div id="secret-{{$idx}}" class="mb-2">

     

       134
       -
                  {{ .Key }} created on {{ .CreatedAt }} by {{ .CreatedBy }}

     

       135
       -
                </div>

     

       136
       -
              {{ end }}

     

       137
       -
             {{ end }}

     

       138
       -
           </div>

     

       139
       -
           <form

     

       140
       -
               hx-put="/{{ $.RepoInfo.FullName }}/settings/secrets"

     

       141
       -
               class="mt-6"

     

       142
       -
               hx-indicator="#add-secret-spinner">

     

       143
       -
               <label for="key">secret key</label>

     

       144
       -
               <input

     

       145
       -
                   type="text"

     

       146
       -
                   id="key"

     

       147
       -
                   name="key"

     

       148
       -
                   required

     

       149
       -
                   class="dark:bg-gray-700 dark:text-white"

     

       150
       -
                   placeholder="SECRET_KEY" />

     

       151
       -
               <label for="value">secret value</label>

     

       152
       -
               <input

     

       153
       -
                   type="text"

     

       154
       -
                   id="value"

     

       155
       -
                   name="value"

     

       156
       -
                   required

     

       157
       -
                   class="dark:bg-gray-700 dark:text-white"

     

       158
       -
                   placeholder="SECRET VALUE" />

     

       159
       -
       

     

       160
       -
             <button class="btn my-2 flex items-center" type="text">

     

       161
       -
                 <span>add</span>

     

       162
       -
                 <span id="add-secret-spinner" class="group">

     

       163
       -
                   {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       164
       -
                 </span>

     

       165
       -
             </button>

     

       166
       -
           </form>

     

       167
       -
         {{ end }}

     

       168
       -
       {{ end }}

-62

appview/db/migrations/20250305_113405.sql

···

       1
       -
       -- Simplified SQLite Database Migration Script for Issues and Comments

     

       2
       -
       

     

       3
       -
       -- Migration for issues table

     

       4
       -
       CREATE TABLE issues_new (

     

       5
       -
           id integer primary key autoincrement,

     

       6
       -
           owner_did text not null,

     

       7
       -
           repo_at text not null,

     

       8
       -
           issue_id integer not null,

     

       9
       -
           title text not null,

     

       10
       -
           body text not null,

     

       11
       -
           open integer not null default 1,

     

       12
       -
           created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       13
       -
           issue_at text,

     

       14
       -
           unique(repo_at, issue_id),

     

       15
       -
           foreign key (repo_at) references repos(at_uri) on delete cascade

     

       16
       -
       );

     

       17
       -
       

     

       18
       -
       -- Migrate data to new issues table

     

       19
       -
       INSERT INTO issues_new (

     

       20
       -
           id, owner_did, repo_at, issue_id,

     

       21
       -
           title, body, open, created, issue_at

     

       22
       -
       )

     

       23
       -
       SELECT

     

       24
       -
           id, owner_did, repo_at, issue_id,

     

       25
       -
           title, body, open, created, issue_at

     

       26
       -
       FROM issues;

     

       27
       -
       

     

       28
       -
       -- Drop old issues table

     

       29
       -
       DROP TABLE issues;

     

       30
       -
       

     

       31
       -
       -- Rename new issues table

     

       32
       -
       ALTER TABLE issues_new RENAME TO issues;

     

       33
       -
       

     

       34
       -
       -- Migration for comments table

     

       35
       -
       CREATE TABLE comments_new (

     

       36
       -
           id integer primary key autoincrement,

     

       37
       -
           owner_did text not null,

     

       38
       -
           issue_id integer not null,

     

       39
       -
           repo_at text not null,

     

       40
       -
           comment_id integer not null,

     

       41
       -
           comment_at text not null,

     

       42
       -
           body text not null,

     

       43
       -
           created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       44
       -
           unique(issue_id, comment_id),

     

       45
       -
           foreign key (repo_at, issue_id) references issues(repo_at, issue_id) on delete cascade

     

       46
       -
       );

     

       47
       -
       

     

       48
       -
       -- Migrate data to new comments table

     

       49
       -
       INSERT INTO comments_new (

     

       50
       -
           id, owner_did, issue_id, repo_at,

     

       51
       -
           comment_id, comment_at, body, created

     

       52
       -
       )

     

       53
       -
       SELECT

     

       54
       -
           id, owner_did, issue_id, repo_at,

     

       55
       -
           comment_id, comment_at, body, created

     

       56
       -
       FROM comments;

     

       57
       -
       

     

       58
       -
       -- Drop old comments table

     

       59
       -
       DROP TABLE comments;

     

       60
       -
       

     

       61
       -
       -- Rename new comments table

     

       62
       -
       ALTER TABLE comments_new RENAME TO comments;

-66

appview/db/migrations/validate.sql

···

       1
       -
       -- Validation Queries for Database Migration

     

       2
       -
       

     

       3
       -
       -- 1. Verify Issues Table Structure

     

       4
       -
       PRAGMA table_info(issues);

     

       5
       -
       

     

       6
       -
       -- 2. Verify Comments Table Structure

     

       7
       -
       PRAGMA table_info(comments);

     

       8
       -
       

     

       9
       -
       -- 3. Check Total Row Count Consistency

     

       10
       -
       SELECT

     

       11
       -
           'Issues Row Count' AS check_type,

     

       12
       -
           (SELECT COUNT(*) FROM issues) AS row_count

     

       13
       -
       UNION ALL

     

       14
       -
       SELECT

     

       15
       -
           'Comments Row Count' AS check_type,

     

       16
       -
           (SELECT COUNT(*) FROM comments) AS row_count;

     

       17
       -
       

     

       18
       -
       -- 4. Verify Unique Constraint on Issues

     

       19
       -
       SELECT

     

       20
       -
           repo_at,

     

       21
       -
           issue_id,

     

       22
       -
           COUNT(*) as duplicate_count

     

       23
       -
       FROM issues

     

       24
       -
       GROUP BY repo_at, issue_id

     

       25
       -
       HAVING duplicate_count > 1;

     

       26
       -
       

     

       27
       -
       -- 5. Verify Foreign Key Integrity for Comments

     

       28
       -
       SELECT

     

       29
       -
           'Orphaned Comments' AS check_type,

     

       30
       -
           COUNT(*) AS orphaned_count

     

       31
       -
       FROM comments c

     

       32
       -
       LEFT JOIN issues i ON c.repo_at = i.repo_at AND c.issue_id = i.issue_id

     

       33
       -
       WHERE i.id IS NULL;

     

       34
       -
       

     

       35
       -
       -- 6. Check Foreign Key Constraint

     

       36
       -
       PRAGMA foreign_key_list(comments);

     

       37
       -
       

     

       38
       -
       -- 7. Sample Data Integrity Check

     

       39
       -
       SELECT

     

       40
       -
           'Sample Issues' AS check_type,

     

       41
       -
           repo_at,

     

       42
       -
           issue_id,

     

       43
       -
           title,

     

       44
       -
           created

     

       45
       -
       FROM issues

     

       46
       -
       LIMIT 5;

     

       47
       -
       

     

       48
       -
       -- 8. Sample Comments Data Integrity Check

     

       49
       -
       SELECT

     

       50
       -
           'Sample Comments' AS check_type,

     

       51
       -
           repo_at,

     

       52
       -
           issue_id,

     

       53
       -
           comment_id,

     

       54
       -
           body,

     

       55
       -
           created

     

       56
       -
       FROM comments

     

       57
       -
       LIMIT 5;

     

       58
       -
       

     

       59
       -
       -- 9. Verify Constraint on Comments (Issue ID and Comment ID Uniqueness)

     

       60
       -
       SELECT

     

       61
       -
           issue_id,

     

       62
       -
           comment_id,

     

       63
       -
           COUNT(*) as duplicate_count

     

       64
       -
       FROM comments

     

       65
       -
       GROUP BY issue_id, comment_id

     

       66
       -
       HAVING duplicate_count > 1;

+14

nix/modules/appview.nix

···

       27
        
                 default = "00000000000000000000000000000000";

     

       28
        
                 description = "Cookie secret";

     

       29
        
               };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
             };

     

       31
        
           };

     

       32
        
       

     
···

       39
        
                 ListenStream = "0.0.0.0:${toString cfg.port}";

     

       40
        
                 ExecStart = "${cfg.package}/bin/appview";

     

       41
        
                 Restart = "always";

     

       0
        
       
     

       42
        
               };

     

       43
        
       

     

       44
        
               environment = {

···

       27
        
                 default = "00000000000000000000000000000000";

     

       28
        
                 description = "Cookie secret";

     

       29
        
               };

     

       30
       +
               environmentFile = mkOption {

     

       31
       +
                 type = with types; nullOr path;

     

       32
       +
                 default = null;

     

       33
       +
                 example = "/etc/tangled-appview.env";

     

       34
       +
                 description = ''

     

       35
       +
                   Additional environment file as defined in {manpage}`systemd.exec(5)`.

     

       36
       +
       

     

       37
       +
                   Sensitive secrets such as {env}`TANGLED_COOKIE_SECRET` may be

     

       38
       +
                   passed to the service without makeing them world readable in the

     

       39
       +
                   nix store.

     

       40
       +
       

     

       41
       +
                 '';

     

       42
       +
               };

     

       43
        
             };

     

       44
        
           };

     

       45
        
       

     
···

       52
        
                 ListenStream = "0.0.0.0:${toString cfg.port}";

     

       53
        
                 ExecStart = "${cfg.package}/bin/appview";

     

       54
        
                 Restart = "always";

     

       55
       +
                 EnvironmentFile = optional (cfg.environmentFile != null) cfg.environmentFile;

     

       56
        
               };

     

       57
        
       

     

       58
        
               environment = {

+1 -1

.air/appview.toml

···

       5
        
       

     

       6
        
       exclude_regex = [".*_templ.go"]

     

       7
        
       include_ext = ["go", "templ", "html", "css"]

     

       8
       -
       exclude_dir = ["target", "atrium"]

···

       5
        
       

     

       6
        
       exclude_regex = [".*_templ.go"]

     

       7
        
       include_ext = ["go", "templ", "html", "css"]

     

       8
       +
       exclude_dir = ["target", "atrium", "nix"]

+1 -1

appview/pages/templates/repo/pipelines/fragments/workflowSymbol.html

···

       19
        
           {{ $color = "text-gray-600 dark:text-gray-500" }}

     

       20
        
         {{ else if eq $kind "timeout" }}

     

       21
        
           {{ $icon = "clock-alert" }}

     

       22
       -
           {{ $color = "text-orange-400 dark:text-orange-300" }}

     

       23
        
         {{ else }}

     

       24
        
           {{ $icon = "x" }}

     

       25
        
           {{ $color = "text-red-600 dark:text-red-500" }}

···

       19
        
           {{ $color = "text-gray-600 dark:text-gray-500" }}

     

       20
        
         {{ else if eq $kind "timeout" }}

     

       21
        
           {{ $icon = "clock-alert" }}

     

       22
       +
           {{ $color = "text-orange-400 dark:text-orange-500" }}

     

       23
        
         {{ else }}

     

       24
        
           {{ $icon = "x" }}

     

       25
        
           {{ $color = "text-red-600 dark:text-red-500" }}

+1 -1

tailwind.config.js

···

       36
        
       					css: {

     

       37
        
       						maxWidth: "none",

     

       38
        
       						pre: {

     

       39
       -
       							"@apply font-normal text-black bg-gray-100 dark:bg-gray-900 dark:text-gray-300 dark:border-gray-700 border": {},

     

       40
        
       						},

     

       41
        
       						code: {

     

       42
        
       							"@apply font-normal font-mono p-1 rounded text-black bg-gray-100 dark:bg-gray-900 dark:text-gray-300 dark:border-gray-700": {},

···

       36
        
       					css: {

     

       37
        
       						maxWidth: "none",

     

       38
        
       						pre: {

     

       39
       +
       							"@apply font-normal text-black bg-gray-50 dark:bg-gray-900 dark:text-gray-300 dark:border-gray-700 border": {},

     

       40
        
       						},

     

       41
        
       						code: {

     

       42
        
       							"@apply font-normal font-mono p-1 rounded text-black bg-gray-100 dark:bg-gray-900 dark:text-gray-300 dark:border-gray-700": {},

+1 -1

nix/pkgs/appview-static-files.nix

···

       22
        
         cp -rf ${lucide-src}/*.svg icons/

     

       23
        
         cp -f ${inter-fonts-src}/web/InterVariable*.woff2 fonts/

     

       24
        
         cp -f ${inter-fonts-src}/web/InterDisplay*.woff2 fonts/

     

       25
       -
         cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono-Regular.woff2 fonts/

     

       26
        
         # tailwindcss -c $src/tailwind.config.js -i $src/input.css -o tw.css won't work

     

       27
        
         # for whatever reason (produces broken css), so we are doing this instead

     

       28
        
         cd ${src} && ${tailwindcss}/bin/tailwindcss -i input.css -o $out/tw.css

···

       22
        
         cp -rf ${lucide-src}/*.svg icons/

     

       23
        
         cp -f ${inter-fonts-src}/web/InterVariable*.woff2 fonts/

     

       24
        
         cp -f ${inter-fonts-src}/web/InterDisplay*.woff2 fonts/

     

       25
       +
         cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono*.woff2 fonts/

     

       26
        
         # tailwindcss -c $src/tailwind.config.js -i $src/input.css -o tw.css won't work

     

       27
        
         # for whatever reason (produces broken css), so we are doing this instead

     

       28
        
         cd ${src} && ${tailwindcss}/bin/tailwindcss -i input.css -o $out/tw.css

+3 -1

log/log.go

···

       9
        
       // NewHandler sets up a new slog.Handler with the service name

     

       10
        
       // as an attribute

     

       11
        
       func NewHandler(name string) slog.Handler {

     

       12
       -
       	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{})

     

       0
        
       
     

       0
        
       
     

       13
        
       

     

       14
        
       	var attrs []slog.Attr

     

       15
        
       	attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})

···

       9
        
       // NewHandler sets up a new slog.Handler with the service name

     

       10
        
       // as an attribute

     

       11
        
       func NewHandler(name string) slog.Handler {

     

       12
       +
       	handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{

     

       13
       +
       		Level: slog.LevelDebug,

     

       14
       +
       	})

     

       15
        
       

     

       16
        
       	var attrs []slog.Attr

     

       17
        
       	attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})

+1 -1

cmd/punchcardPopulate/main.go

···

       11
        
       )

     

       12
        
       

     

       13
        
       func main() {

     

       14
       -
       	db, err := sql.Open("sqlite3", "./appview.db")

     

       15
        
       	if err != nil {

     

       16
        
       		log.Fatal("Failed to open database:", err)

     

       17
        
       	}

···

       11
        
       )

     

       12
        
       

     

       13
        
       func main() {

     

       14
       +
       	db, err := sql.Open("sqlite3", "./appview.db?_foreign_keys=1")

     

       15
        
       	if err != nil {

     

       16
        
       		log.Fatal("Failed to open database:", err)

     

       17
        
       	}

+1 -1

spindle/secrets/sqlite.go

···

       24
        
       }

     

       25
        
       

     

       26
        
       func NewSQLiteManager(dbPath string, opts ...SqliteManagerOpt) (*SqliteManager, error) {

     

       27
       -
       	db, err := sql.Open("sqlite3", dbPath)

     

       28
        
       	if err != nil {

     

       29
        
       		return nil, fmt.Errorf("failed to open sqlite database: %w", err)

     

       30
        
       	}

···

       24
        
       }

     

       25
        
       

     

       26
        
       func NewSQLiteManager(dbPath string, opts ...SqliteManagerOpt) (*SqliteManager, error) {

     

       27
       +
       	db, err := sql.Open("sqlite3", dbPath+"?_foreign_keys=1")

     

       28
        
       	if err != nil {

     

       29
        
       		return nil, fmt.Errorf("failed to open sqlite database: %w", err)

     

       30
        
       	}

+14 -9

knotserver/db/init.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"database/sql"

     

       0
        
       
     

       5
        
       

     

       6
        
       	_ "github.com/mattn/go-sqlite3"

     

       7
        
       )

     
···

       11
        
       }

     

       12
        
       

     

       13
        
       func Setup(dbPath string) (*DB, error) {

     

       14
       -
       	db, err := sql.Open("sqlite3", dbPath+"?_foreign_keys=1")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
       	if err != nil {

     

       16
        
       		return nil, err

     

       17
        
       	}

     

       18
        
       

     

       19
       -
       	_, err = db.Exec(`

     

       20
       -
       		pragma journal_mode = WAL;

     

       21
       -
       		pragma synchronous = normal;

     

       22
       -
       		pragma temp_store = memory;

     

       23
       -
       		pragma mmap_size = 30000000000;

     

       24
       -
       		pragma page_size = 32768;

     

       25
       -
       		pragma auto_vacuum = incremental;

     

       26
       -
       		pragma busy_timeout = 5000;

     

       27
        
       

     

       0
        
       
     

       28
        
       		create table if not exists known_dids (

     

       29
        
       			did text primary key

     

       30
        
       		);

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"database/sql"

     

       5
       +
       	"strings"

     

       6
        
       

     

       7
        
       	_ "github.com/mattn/go-sqlite3"

     

       8
        
       )

     
···

       12
        
       }

     

       13
        
       

     

       14
        
       func Setup(dbPath string) (*DB, error) {

     

       15
       +
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       16
       +
       	opts := []string{

     

       17
       +
       		"_foreign_keys=1",

     

       18
       +
       		"_journal_mode=WAL",

     

       19
       +
       		"_synchronous=NORMAL",

     

       20
       +
       		"_auto_vacuum=incremental",

     

       21
       +
       	}

     

       22
       +
       

     

       23
       +
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       24
        
       	if err != nil {

     

       25
        
       		return nil, err

     

       26
        
       	}

     

       27
        
       

     

       28
       +
       	// NOTE: If any other migration is added here, you MUST

     

       29
       +
       	// copy the pattern in appview: use a single sql.Conn

     

       30
       +
       	// for every migration.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       

     

       32
       +
       	_, err = db.Exec(`

     

       33
        
       		create table if not exists known_dids (

     

       34
        
       			did text primary key

     

       35
        
       		);

+14 -9

spindle/db/db.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"database/sql"

     

       0
        
       
     

       5
        
       

     

       6
        
       	_ "github.com/mattn/go-sqlite3"

     

       7
        
       )

     
···

       11
        
       }

     

       12
        
       

     

       13
        
       func Make(dbPath string) (*DB, error) {

     

       14
       -
       	db, err := sql.Open("sqlite3", dbPath+"?_foreign_keys=1")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
       	if err != nil {

     

       16
        
       		return nil, err

     

       17
        
       	}

     

       18
        
       

     

       19
       -
       	_, err = db.Exec(`

     

       20
       -
       		pragma journal_mode = WAL;

     

       21
       -
       		pragma synchronous = normal;

     

       22
       -
       		pragma temp_store = memory;

     

       23
       -
       		pragma mmap_size = 30000000000;

     

       24
       -
       		pragma page_size = 32768;

     

       25
       -
       		pragma auto_vacuum = incremental;

     

       26
       -
       		pragma busy_timeout = 5000;

     

       27
        
       

     

       0
        
       
     

       28
        
       		create table if not exists _jetstream (

     

       29
        
       			id integer primary key autoincrement,

     

       30
        
       			last_time_us integer not null

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"database/sql"

     

       5
       +
       	"strings"

     

       6
        
       

     

       7
        
       	_ "github.com/mattn/go-sqlite3"

     

       8
        
       )

     
···

       12
        
       }

     

       13
        
       

     

       14
        
       func Make(dbPath string) (*DB, error) {

     

       15
       +
       	// https://github.com/mattn/go-sqlite3#connection-string

     

       16
       +
       	opts := []string{

     

       17
       +
       		"_foreign_keys=1",

     

       18
       +
       		"_journal_mode=WAL",

     

       19
       +
       		"_synchronous=NORMAL",

     

       20
       +
       		"_auto_vacuum=incremental",

     

       21
       +
       	}

     

       22
       +
       

     

       23
       +
       	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       24
        
       	if err != nil {

     

       25
        
       		return nil, err

     

       26
        
       	}

     

       27
        
       

     

       28
       +
       	// NOTE: If any other migration is added here, you MUST

     

       29
       +
       	// copy the pattern in appview: use a single sql.Conn

     

       30
       +
       	// for every migration.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
       

     

       32
       +
       	_, err = db.Exec(`

     

       33
        
       		create table if not exists _jetstream (

     

       34
        
       			id integer primary key autoincrement,

     

       35
        
       			last_time_us integer not null

+12

.prettierrc.json

···

       1
       +
       {

     

       2
       +
         "overrides": [

     

       3
       +
           {

     

       4
       +
             "files": ["*.html"],

     

       5
       +
             "options": {

     

       6
       +
               "parser": "go-template"

     

       7
       +
             }

     

       8
       +
           }

     

       9
       +
         ],

     

       10
       +
         "bracketSameLine": true,

     

       11
       +
         "htmlWhitespaceSensitivity": "ignore"

     

       12
       +
       }

-16

.zed/settings.json

···

       1
       -
       // Folder-specific settings

     

       2
       -
       //

     

       3
       -
       // For a full list of overridable settings, and general information on folder-specific settings,

     

       4
       -
       // see the documentation: https://zed.dev/docs/configuring-zed#settings-files

     

       5
       -
       {

     

       6
       -
         "languages": {

     

       7
       -
           "HTML": {

     

       8
       -
             "prettier": {

     

       9
       -
               "format_on_save": false,

     

       10
       -
               "allowed": true,

     

       11
       -
               "parser": "go-template",

     

       12
       -
               "plugins": ["prettier-plugin-go-template"]

     

       13
       -
             }

     

       14
       -
           }

     

       15
       -
         }

     

       16
       -
       }

+37 -83

appview/pages/templates/layouts/footer.html

···

       1
        
       {{ define "layouts/footer" }}

     

       2
       -
         <div

     

       3
       -
           class="w-full p-4 md:p-8 bg-white dark:bg-gray-800 rounded-t drop-shadow-sm">

     

       4
       -
           <div class="container mx-auto max-w-7xl px-4">

     

       5
       -
             <div

     

       6
       -
               class="flex flex-col lg:flex-row justify-between items-start text-gray-600 dark:text-gray-400 text-sm gap-8">

     

       7
       -
               <div class="mb-4 md:mb-0">

     

       8
       -
                 <a href="/" hx-boost="true" class="flex gap-2 font-semibold italic">

     

       9
       -
                   tangled

     

       10
       -
                   <sub>alpha</sub>

     

       11
       -
                 </a>

     

       12
       -
               </div>

     

       13
       -
       

     

       14
       -
               {{ $headerStyle := "text-gray-900 dark:text-gray-200 font-bold text-xs uppercase tracking-wide mb-1" }}

     

       15
       -
               {{ $linkStyle := "text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-200 hover:underline inline-flex gap-1 items-center" }}

     

       16
       -
               {{ $iconStyle := "w-4 h-4 flex-shrink-0" }}

     

       17
       -
               <div

     

       18
       -
                 class="grid grid-cols-1 sm:grid-cols-1 md:grid-cols-4 sm:gap-6 md:gap-2 gap-6 flex-1">

     

       19
       -
                 <div class="flex flex-col gap-1">

     

       20
       -
                   <div class="{{ $headerStyle }}">legal</div>

     

       21
       -
                   <a href="/terms" class="{{ $linkStyle }}">

     

       22
       -
                     {{ i "file-text" $iconStyle }} terms of service

     

       23
       -
                   </a>

     

       24
       -
                   <a href="/privacy" class="{{ $linkStyle }}">

     

       25
       -
                     {{ i "shield" $iconStyle }} privacy policy

     

       26
       -
                   </a>

     

       27
       -
                 </div>

     

       28
        
       

     

       29
       -
                 <div class="flex flex-col gap-1">

     

       30
       -
                   <div class="{{ $headerStyle }}">resources</div>

     

       31
       -
                   <a

     

       32
       -
                     href="https://blog.tangled.sh"

     

       33
       -
                     class="{{ $linkStyle }}"

     

       34
       -
                     target="_blank"

     

       35
       -
                     rel="noopener noreferrer">

     

       36
       -
                     {{ i "book-open" $iconStyle }} blog

     

       37
       -
                   </a>

     

       38
       -
                   <a

     

       39
       -
                     href="https://tangled.sh/@tangled.sh/core/tree/master/docs"

     

       40
       -
                     class="{{ $linkStyle }}">

     

       41
       -
                     {{ i "book" $iconStyle }} docs

     

       42
       -
                   </a>

     

       43
       -
                   <a

     

       44
       -
                     href="https://tangled.sh/@tangled.sh/core"

     

       45
       -
                     class="{{ $linkStyle }}">

     

       46
       -
                     {{ i "code" $iconStyle }} source

     

       47
       -
                   </a>

     

       48
       -
                 </div>

     

       49
        
       

     

       50
       -
                 <div class="flex flex-col gap-1">

     

       51
       -
                   <div class="{{ $headerStyle }}">social</div>

     

       52
       -
                   <a

     

       53
       -
                     href="https://chat.tangled.sh"

     

       54
       -
                     class="{{ $linkStyle }}"

     

       55
       -
                     target="_blank"

     

       56
       -
                     rel="noopener noreferrer">

     

       57
       -
                     {{ i "message-circle" $iconStyle }} discord

     

       58
       -
                   </a>

     

       59
       -
                   <a

     

       60
       -
                     href="https://web.libera.chat/#tangled"

     

       61
       -
                     class="{{ $linkStyle }}"

     

       62
       -
                     target="_blank"

     

       63
       -
                     rel="noopener noreferrer">

     

       64
       -
                     {{ i "hash" $iconStyle }} irc

     

       65
       -
                   </a>

     

       66
       -
                   <a

     

       67
       -
                     href="https://bsky.app/profile/tangled.sh"

     

       68
       -
                     class="{{ $linkStyle }}"

     

       69
       -
                     target="_blank"

     

       70
       -
                     rel="noopener noreferrer">

     

       71
       -
                     {{ template "user/fragments/bluesky" $iconStyle }} bluesky

     

       72
       -
                   </a>

     

       73
       -
                 </div>

     

       74
        
       

     

       75
       -
                 <div class="flex flex-col gap-1">

     

       76
       -
                   <div class="{{ $headerStyle }}">contact</div>

     

       77
       -
                   <a href="mailto:team@tangled.sh" class="{{ $linkStyle }}">

     

       78
       -
                     {{ i "mail" "w-4 h-4 flex-shrink-0" }} team@tangled.sh

     

       79
       -
                   </a>

     

       80
       -
                   <a href="mailto:security@tangled.sh" class="{{ $linkStyle }}">

     

       81
       -
                     {{ i "shield-check" "w-4 h-4 flex-shrink-0" }} security@tangled.sh

     

       82
       -
                   </a>

     

       83
       -
                 </div>

     

       84
        
               </div>

     

       85
        
       

     

       86
       -
               <div class="text-center lg:text-right flex-shrink-0">

     

       87
       -
                 <div class="text-xs">

     

       88
       -
                   &copy; 2025 Tangled Labs Oy. All rights reserved.

     

       89
       -
                 </div>

     

       90
        
               </div>

     

       91
        
             </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92
        
           </div>

     

       93
        
         </div>

     

       0
        
       
     

       94
        
       {{ end }}

···

       1
        
       {{ define "layouts/footer" }}

     

       2
       +
       <div class="w-full p-4 md:p-8 bg-white dark:bg-gray-800 rounded-t drop-shadow-sm">

     

       3
       +
         <div class="container mx-auto max-w-7xl px-4">

     

       4
       +
           <div class="flex flex-col lg:flex-row justify-between items-start text-gray-600 dark:text-gray-400 text-sm gap-8">

     

       5
       +
             <div class="mb-4 md:mb-0">

     

       6
       +
               <a href="/" hx-boost="true" class="flex gap-2 font-semibold italic">

     

       7
       +
                 tangled<sub>alpha</sub>

     

       8
       +
               </a>

     

       9
       +
             </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       

     

       11
       +
             {{ $headerStyle := "text-gray-900 dark:text-gray-200 font-bold text-xs uppercase tracking-wide mb-1" }}

     

       12
       +
             {{ $linkStyle := "text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-200 hover:underline inline-flex gap-1 items-center" }}

     

       13
       +
             {{ $iconStyle := "w-4 h-4 flex-shrink-0" }}

     

       14
       +
             <div class="grid grid-cols-1 sm:grid-cols-1 md:grid-cols-4 sm:gap-6 md:gap-2 gap-6 flex-1">

     

       15
       +
               <div class="flex flex-col gap-1">

     

       16
       +
                 <div class="{{ $headerStyle }}">legal</div>

     

       17
       +
                 <a href="/terms" class="{{ $linkStyle }}">{{ i "file-text" $iconStyle }} terms of service</a>

     

       18
       +
                 <a href="/privacy" class="{{ $linkStyle }}">{{ i "shield" $iconStyle }} privacy policy</a>

     

       19
       +
               </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
       +
               <div class="flex flex-col gap-1">

     

       22
       +
                 <div class="{{ $headerStyle }}">resources</div>

     

       23
       +
                 <a href="https://blog.tangled.sh" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a>

     

       24
       +
                 <a href="https://tangled.sh/@tangled.sh/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a>

     

       25
       +
                 <a href="https://tangled.sh/@tangled.sh/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a>

     

       26
       +
               </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
       +
               <div class="flex flex-col gap-1">

     

       29
       +
                 <div class="{{ $headerStyle }}">social</div>

     

       30
       +
                 <a href="https://chat.tangled.sh" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "message-circle" $iconStyle }} discord</a>

     

       31
       +
                 <a href="https://web.libera.chat/#tangled" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "hash" $iconStyle }} irc</a>

     

       32
       +
                 <a href="https://bsky.app/profile/tangled.sh" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ template "user/fragments/bluesky" $iconStyle }} bluesky</a>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
               </div>

     

       34
        
       

     

       35
       +
               <div class="flex flex-col gap-1">

     

       36
       +
                 <div class="{{ $headerStyle }}">contact</div>

     

       37
       +
                 <a href="mailto:team@tangled.sh" class="{{ $linkStyle }}">{{ i "mail" "w-4 h-4 flex-shrink-0" }} team@tangled.sh</a>

     

       38
       +
                 <a href="mailto:security@tangled.sh" class="{{ $linkStyle }}">{{ i "shield-check" "w-4 h-4 flex-shrink-0" }} security@tangled.sh</a>

     

       39
        
               </div>

     

       40
        
             </div>

     

       41
       +
       

     

       42
       +
             <div class="text-center lg:text-right flex-shrink-0">

     

       43
       +
               <div class="text-xs">&copy; 2025 Tangled Labs Oy. All rights reserved.</div>

     

       44
       +
             </div>

     

       45
        
           </div>

     

       46
        
         </div>

     

       47
       +
       </div>

     

       48
        
       {{ end }}

+9 -16

appview/pages/templates/repo/compare/new.html

···

       1
        
       {{ define "title" }}

     

       2
       -
         compare refs on

     

       3
       -
         {{ .RepoInfo.FullName }}

     

       4
        
       {{ end }}

     

       5
        
       

     

       6
        
       {{ define "repoContent" }}

     
···

       10
        
       {{ define "repoAfter" }}

     

       11
        
         {{ $brs := take .Branches 5 }}

     

       12
        
         {{ if $brs }}

     

       13
       -
           <section

     

       14
       -
             class="p-6 mt-4 rounded-br rounded-bl bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm w-full mx-auto">

     

       15
        
             <div class="flex flex-col items-center">

     

       16
        
               <p class="text-center text-black dark:text-white">

     

       17
       -
                 Recently updated branches in this repository:

     

       18
        
               </p>

     

       19
       -
               <div

     

       20
       -
                 class="mt-4 grid grid-cols-1 divide-y divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 w-full md:w-1/2">

     

       21
       -
                 {{ range $br := $brs }}

     

       22
       -
                   <a

     

       23
       -
                     href="/{{ $.RepoInfo.FullName }}/compare?head={{ $br.Name | urlquery }}"

     

       24
       -
                     class="no-underline hover:no-underline">

     

       25
        
                     <div class="flex items-center justify-between p-2">

     

       26
        
                       {{ $br.Name }}

     

       27
       -
                       <span class="text-gray-500 dark:text-gray-400">

     

       28
       -
                         {{ template "repo/fragments/time" $br.Commit.Committer.When }}

     

       29
       -
                       </span>

     

       30
        
                     </div>

     

       31
        
                   </a>

     

       32
       -
                 {{ end }}

     

       33
       -
               </div>

     

       34
        
             </div>

     

       35
        
           </section>

     

       36
        
         {{ end }}

···

       1
        
       {{ define "title" }}

     

       2
       +
         compare refs on {{ .RepoInfo.FullName }}

     

       0
        
       
     

       3
        
       {{ end }}

     

       4
        
       

     

       5
        
       {{ define "repoContent" }}

     
···

       9
        
       {{ define "repoAfter" }}

     

       10
        
         {{ $brs := take .Branches 5 }}

     

       11
        
         {{ if $brs }}

     

       12
       +
           <section class="p-6 mt-4 rounded-br rounded-bl bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm w-full mx-auto">

     

       0
        
       
     

       13
        
             <div class="flex flex-col items-center">

     

       14
        
               <p class="text-center text-black dark:text-white">

     

       15
       +
               Recently updated branches in this repository:

     

       16
        
               </p>

     

       17
       +
                 <div class="mt-4 grid grid-cols-1 divide-y divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 w-full md:w-1/2">

     

       18
       +
                   {{ range $br := $brs }}

     

       19
       +
                   <a href="/{{ $.RepoInfo.FullName }}/compare?head={{ $br.Name | urlquery }}" class="no-underline hover:no-underline">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
                     <div class="flex items-center justify-between p-2">

     

       21
        
                       {{ $br.Name }}

     

       22
       +
                       <span class="text-gray-500 dark:text-gray-400">{{ template "repo/fragments/time" $br.Commit.Committer.When }}</span>

     

       0
        
       
     

       0
        
       
     

       23
        
                     </div>

     

       24
        
                   </a>

     

       25
       +
                   {{ end }}

     

       26
       +
                 </div>

     

       27
        
             </div>

     

       28
        
           </section>

     

       29
        
         {{ end }}

+13 -27

appview/pages/templates/repo/fragments/artifact.html

···

       1
        
       {{ define "repo/fragments/artifact" }}

     

       2
       -
         {{ $unique := .Artifact.BlobCid.String }}

     

       3
       -
         <div

     

       4
       -
           id="artifact-{{ $unique }}"

     

       5
       -
           class="flex items-center justify-between p-2 border-b border-gray-200 dark:border-gray-700">

     

       6
       -
           <div id="left-side" class="flex items-center gap-2 min-w-0 max-w-[60%]">

     

       7
       -
             {{ i "box" "w-4 h-4" }}

     

       8
       -
             <a

     

       9
       -
               href="/{{ .RepoInfo.FullName }}/tags/{{ .Artifact.Tag.String }}/download/{{ .Artifact.Name | urlquery }}"

     

       10
       -
               class="no-underline hover:no-underline">

     

       11
       -
               {{ .Artifact.Name }}

     

       12
       -
             </a>

     

       13
       -
             <span class="text-gray-500 dark:text-gray-400 pl-2 text-sm">

     

       14
       -
               {{ byteFmt .Artifact.Size }}

     

       15
       -
             </span>

     

       16
       -
           </div>

     

       17
        
       

     

       18
       -
           <div

     

       19
       -
             id="right-side"

     

       20
       -
             class="text-gray-500 dark:text-gray-400 flex items-center flex-shrink-0 gap-2 text-sm">

     

       21
       -
             <span class="hidden md:inline">

     

       22
       -
               {{ template "repo/fragments/time" .Artifact.CreatedAt }}

     

       23
       -
             </span>

     

       24
       -
             <span class="       md:hidden">

     

       25
       -
               {{ template "repo/fragments/shortTime" .Artifact.CreatedAt }}

     

       26
       -
             </span>

     

       27
        
       

     

       28
        
             <span class="select-none after:content-['·'] hidden md:inline"></span>

     

       29
       -
             <span class="truncate max-w-[100px] hidden md:inline">

     

       30
       -
               {{ .Artifact.MimeType }}

     

       31
       -
             </span>

     

       32
        
       

     

       33
        
             {{ if and .LoggedInUser (eq .LoggedInUser.Did .Artifact.Did) }}

     

       34
        
               <button

···

       1
        
       {{ define "repo/fragments/artifact" }}

     

       2
       +
       {{ $unique := .Artifact.BlobCid.String }}

     

       3
       +
         <div id="artifact-{{ $unique }}" class="flex items-center justify-between p-2 border-b border-gray-200 dark:border-gray-700">

     

       4
       +
             <div id="left-side" class="flex items-center gap-2 min-w-0 max-w-[60%]">

     

       5
       +
               {{ i "box" "w-4 h-4" }}

     

       6
       +
               <a href="/{{ .RepoInfo.FullName }}/tags/{{ .Artifact.Tag.String }}/download/{{ .Artifact.Name | urlquery }}" class="no-underline hover:no-underline">

     

       7
       +
                 {{ .Artifact.Name }}

     

       8
       +
               </a>

     

       9
       +
               <span class="text-gray-500 dark:text-gray-400 pl-2 text-sm">{{ byteFmt .Artifact.Size }}</span>

     

       10
       +
             </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       +
           <div id="right-side" class="text-gray-500 dark:text-gray-400 flex items-center flex-shrink-0 gap-2 text-sm">

     

       13
       +
             <span class="hidden md:inline">{{ template "repo/fragments/time" .Artifact.CreatedAt }}</span>

     

       14
       +
             <span class="       md:hidden">{{ template "repo/fragments/shortTime" .Artifact.CreatedAt }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
       

     

       16
        
             <span class="select-none after:content-['·'] hidden md:inline"></span>

     

       17
       +
             <span class="truncate max-w-[100px] hidden md:inline">{{ .Artifact.MimeType }}</span>

     

       0
        
       
     

       0
        
       
     

       18
        
       

     

       19
        
             {{ if and .LoggedInUser (eq .LoggedInUser.Did .Artifact.Did) }}

     

       20
        
               <button

+54 -63

appview/pages/templates/repo/fragments/compareForm.html

···

       1
        
       {{ define "repo/fragments/compareForm" }}

     

       2
       -
         <div id="compare-select">

     

       3
       -
           <h2 class="font-bold text-sm mb-2 uppercase dark:text-white">

     

       4
       -
             Compare changes

     

       5
       -
           </h2>

     

       6
       -
           <p>Choose any two refs to compare.</p>

     

       7
        
       

     

       8
       -
           <form id="compare-form" class="flex items-center gap-2 py-4">

     

       9
       -
             <div>

     

       10
       -
               <span class="hidden md:inline">base:</span>

     

       11
       -
               {{ block "dropdown" (list $ "base" $.Base) }}{{ end }}

     

       12
       -
             </div>

     

       13
       -
             <span class="flex-shrink-0">

     

       14
       -
               {{ i "arrow-left" "w-4 h-4" }}

     

       15
       -
             </span>

     

       16
       -
             <div>

     

       17
       -
               <span class="hidden md:inline">compare:</span>

     

       18
       -
               {{ block "dropdown" (list $ "head" $.Head) }}{{ end }}

     

       19
       -
             </div>

     

       20
       -
             <button

     

       21
       -
               id="compare-button"

     

       22
       -
               class="btn disabled:opacity-50 disabled:cursor-not-allowed"

     

       23
       -
               type="button"

     

       24
       -
               hx-boost="true"

     

       25
       -
               onclick="

     

       26
        
               const base = document.getElementById('base-select').value;

     

       27
        
               const head = document.getElementById('head-select').value;

     

       28
       -
               window.location.href = `/{{ $.RepoInfo.FullName }}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`;

     

       29
        
              ">

     

       30
       -
               go

     

       31
       -
             </button>

     

       32
       -
           </form>

     

       33
       -
         </div>

     

       34
       -
         <script>

     

       35
       -
           const baseSelect = document.getElementById("base-select");

     

       36
       -
           const headSelect = document.getElementById("head-select");

     

       37
       -
           const compareButton = document.getElementById("compare-button");

     

       38
        
       

     

       39
       -
           function toggleButtonState() {

     

       40
       -
             compareButton.disabled = baseSelect.value === headSelect.value;

     

       41
       -
           }

     

       42
        
       

     

       43
       -
           baseSelect.addEventListener("change", toggleButtonState);

     

       44
       -
           headSelect.addEventListener("change", toggleButtonState);

     

       45
        
       

     

       46
       -
           // Run once on page load

     

       47
       -
           toggleButtonState();

     

       48
       -
         </script>

     

       49
        
       {{ end }}

     

       50
        
       

     

       51
        
       {{ define "dropdown" }}

     

       52
       -
         {{ $root := index . 0 }}

     

       53
       -
         {{ $name := index . 1 }}

     

       54
       -
         {{ $default := index . 2 }}

     

       55
       -
         <select

     

       56
       -
           name="{{ $name }}"

     

       57
       -
           id="{{ $name }}-select"

     

       58
       -
           class="p-1 border max-w-32 md:max-w-64 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">

     

       59
        
           <optgroup label="branches ({{ len $root.Branches }})" class="bold text-sm">

     

       60
        
             {{ range $root.Branches }}

     

       61
       -
               <option

     

       62
       -
                 value="{{ .Reference.Name }}"

     

       63
       -
                 class="py-1"

     

       64
       -
                 {{ if eq .Reference.Name $default }}selected{{ end }}>

     

       65
        
                 {{ .Reference.Name }}

     

       66
        
               </option>

     

       67
        
             {{ end }}

     

       68
        
           </optgroup>

     

       69
       -
           <optgroup label="tags ({{ len $root.Tags }})" class="bold text-sm">

     

       70
       -
             {{ range $root.Tags }}

     

       71
       -
               <option

     

       72
       -
                 value="{{ .Reference.Name }}"

     

       73
       -
                 class="py-1"

     

       74
       -
                 {{ if eq .Reference.Name $default }}selected{{ end }}>

     

       75
       -
                 {{ .Reference.Name }}

     

       76
       -
               </option>

     

       77
       -
             {{ else }}

     

       78
       -
               <option class="py-1" disabled>no tags found</option>

     

       79
       -
             {{ end }}

     

       80
       -
           </optgroup>

     

       81
        
         </select>

     

       82
        
       {{ end }}

···

       1
        
       {{ define "repo/fragments/compareForm" }}

     

       2
       +
       <div id="compare-select">

     

       3
       +
         <h2 class="font-bold text-sm mb-2 uppercase dark:text-white">

     

       4
       +
           Compare changes

     

       5
       +
         </h2>

     

       6
       +
         <p>Choose any two refs to compare.</p>

     

       7
        
       

     

       8
       +
         <form id="compare-form" class="flex items-center gap-2 py-4">

     

       9
       +
           <div>

     

       10
       +
             <span class="hidden md:inline">base:</span>

     

       11
       +
             {{ block "dropdown" (list $ "base" $.Base) }} {{ end }}

     

       12
       +
           </div>

     

       13
       +
           <span class="flex-shrink-0">

     

       14
       +
             {{ i "arrow-left" "w-4 h-4" }}

     

       15
       +
           </span>

     

       16
       +
           <div>

     

       17
       +
             <span class="hidden md:inline">compare:</span>

     

       18
       +
             {{ block "dropdown" (list $ "head" $.Head) }} {{ end }}

     

       19
       +
           </div>

     

       20
       +
           <button

     

       21
       +
             id="compare-button"

     

       22
       +
             class="btn disabled:opacity-50 disabled:cursor-not-allowed"

     

       23
       +
             type="button"

     

       24
       +
             hx-boost="true"

     

       25
       +
             onclick="

     

       26
        
               const base = document.getElementById('base-select').value;

     

       27
        
               const head = document.getElementById('head-select').value;

     

       28
       +
               window.location.href = `/{{$.RepoInfo.FullName}}/compare/${encodeURIComponent(base)}...${encodeURIComponent(head)}`;

     

       29
        
              ">

     

       30
       +
             go

     

       31
       +
           </button>

     

       32
       +
         </form>

     

       33
       +
       </div>

     

       34
       +
       <script>

     

       35
       +
         const baseSelect = document.getElementById('base-select');

     

       36
       +
         const headSelect = document.getElementById('head-select');

     

       37
       +
         const compareButton = document.getElementById('compare-button');

     

       38
        
       

     

       39
       +
         function toggleButtonState() {

     

       40
       +
           compareButton.disabled = baseSelect.value === headSelect.value;

     

       41
       +
         }

     

       42
        
       

     

       43
       +
         baseSelect.addEventListener('change', toggleButtonState);

     

       44
       +
         headSelect.addEventListener('change', toggleButtonState);

     

       45
        
       

     

       46
       +
         // Run once on page load

     

       47
       +
         toggleButtonState();

     

       48
       +
       </script>

     

       49
        
       {{ end }}

     

       50
        
       

     

       51
        
       {{ define "dropdown" }}

     

       52
       +
       {{ $root := index . 0 }}

     

       53
       +
       {{ $name := index . 1 }}

     

       54
       +
       {{ $default := index . 2 }}

     

       55
       +
         <select name="{{$name}}" id="{{$name}}-select" class="p-1 border max-w-32 md:max-w-64 border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       56
        
           <optgroup label="branches ({{ len $root.Branches }})" class="bold text-sm">

     

       57
        
             {{ range $root.Branches }}

     

       58
       +
               <option value="{{ .Reference.Name }}" class="py-1" {{if eq .Reference.Name $default}}selected{{end}}>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
                 {{ .Reference.Name }}

     

       60
        
               </option>

     

       61
        
             {{ end }}

     

       62
        
           </optgroup>

     

       63
       +
             <optgroup label="tags ({{ len $root.Tags }})" class="bold text-sm">

     

       64
       +
               {{ range $root.Tags }}

     

       65
       +
                 <option value="{{ .Reference.Name }}" class="py-1" {{if eq .Reference.Name $default}}selected{{end}}>

     

       66
       +
                   {{ .Reference.Name }}

     

       67
       +
                 </option>

     

       68
       +
               {{ else }}

     

       69
       +
                 <option class="py-1" disabled>no tags found</option>

     

       70
       +
               {{ end }}

     

       71
       +
             </optgroup>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
         </select>

     

       73
        
       {{ end }}

+6 -14

appview/pages/templates/repo/fragments/diffOpts.html

···

       1
        
       {{ define "repo/fragments/diffOpts" }}

     

       2
       -
         <section

     

       3
       -
           class="flex flex-col gap-2 overflow-x-auto text-sm px-6 py-2 border border-gray-200 dark:border-gray-700 w-full mx-auto rounded bg-white dark:bg-gray-800 drop-shadow-sm">

     

       4
        
           <strong class="text-sm uppercase dark:text-gray-200">options</strong>

     

       5
        
           {{ $active := "unified" }}

     

       6
        
           {{ if .Split }}

     

       7
        
             {{ $active = "split" }}

     

       8
        
           {{ end }}

     

       9
        
           {{ $values := list "unified" "split" }}

     

       10
       -
           {{ block "tabSelector" (dict "Name" "diff" "Values" $values "Active" $active) }}

     

       11
       -
           {{ end }}

     

       12
        
         </section>

     

       13
        
       {{ end }}

     

       14
        
       

     
···

       16
        
         {{ $name := .Name }}

     

       17
        
         {{ $all := .Values }}

     

       18
        
         {{ $active := .Active }}

     

       19
       -
         <div

     

       20
       -
           class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden">

     

       21
        
           {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }}

     

       22
        
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }}

     

       23
        
           {{ range $index, $value := $all }}

     

       24
        
             {{ $isActive := eq $value $active }}

     

       25
       -
             <a

     

       26
       -
               href="?{{ $name }}={{ $value }}"

     

       27
       -
               class="py-2 text-sm w-full block hover:no-underline text-center {{ if $isActive }}

     

       28
       -
                 {{ $activeTab }}

     

       29
       -
               {{ else }}

     

       30
       -
                 {{ $inactiveTab }}

     

       31
       -
               {{ end }}">

     

       32
       -
               {{ $value }}

     

       33
        
             </a>

     

       34
        
           {{ end }}

     

       35
        
         </div>

···

       1
        
       {{ define "repo/fragments/diffOpts" }}

     

       2
       +
         <section class="flex flex-col gap-2 overflow-x-auto text-sm px-6 py-2 border border-gray-200 dark:border-gray-700 w-full mx-auto rounded bg-white dark:bg-gray-800 drop-shadow-sm">

     

       0
        
       
     

       3
        
           <strong class="text-sm uppercase dark:text-gray-200">options</strong>

     

       4
        
           {{ $active := "unified" }}

     

       5
        
           {{ if .Split }}

     

       6
        
             {{ $active = "split" }}

     

       7
        
           {{ end }}

     

       8
        
           {{ $values := list "unified" "split" }}

     

       9
       +
           {{ block "tabSelector" (dict "Name" "diff" "Values" $values "Active" $active) }} {{ end }}

     

       0
        
       
     

       10
        
         </section>

     

       11
        
       {{ end }}

     

       12
        
       

     
···

       14
        
         {{ $name := .Name }}

     

       15
        
         {{ $all := .Values }}

     

       16
        
         {{ $active := .Active }}

     

       17
       +
         <div class="flex justify-between divide-x divide-gray-200 dark:divide-gray-700 rounded border border-gray-200 dark:border-gray-700 overflow-hidden">

     

       0
        
       
     

       18
        
           {{ $activeTab := "bg-white dark:bg-gray-700 shadow-sm" }}

     

       19
        
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800 shadow-inner" }}

     

       20
        
           {{ range $index, $value := $all }}

     

       21
        
             {{ $isActive := eq $value $active }}

     

       22
       +
             <a href="?{{ $name }}={{ $value }}"

     

       23
       +
                class="py-2 text-sm w-full block hover:no-underline text-center {{ if $isActive }} {{$activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       24
       +
              {{ $value }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
             </a>

     

       26
        
           {{ end }}

     

       27
        
         </div>

+5 -16

appview/pages/templates/repo/fragments/diffStatPill.html

···

       1
        
       {{ define "repo/fragments/diffStatPill" }}

     

       2
        
         <div class="flex items-center font-mono text-sm">

     

       3
        
           {{ if and .Insertions .Deletions }}

     

       4
       -
             <span

     

       5
       -
               class="rounded-l p-1 select-none bg-green-100 text-green-700 dark:bg-green-800/50 dark:text-green-400">

     

       6
       -
               +{{ .Insertions }}

     

       7
       -
             </span>

     

       8
       -
             <span

     

       9
       -
               class="rounded-r p-1 select-none bg-red-100 text-red-700 dark:bg-red-800/50 dark:text-red-400">

     

       10
       -
               -{{ .Deletions }}

     

       11
       -
             </span>

     

       12
        
           {{ else if .Insertions }}

     

       13
       -
             <span

     

       14
       -
               class="rounded p-1 select-none bg-green-100 text-green-700 dark:bg-green-800/50 dark:text-green-400">

     

       15
       -
               +{{ .Insertions }}

     

       16
       -
             </span>

     

       17
        
           {{ else if .Deletions }}

     

       18
       -
             <span

     

       19
       -
               class="rounded p-1 select-none bg-red-100 text-red-700 dark:bg-red-800/50 dark:text-red-400">

     

       20
       -
               -{{ .Deletions }}

     

       21
       -
             </span>

     

       22
        
           {{ end }}

     

       23
        
         </div>

     

       24
        
       {{ end }}

     

       0

···

       1
        
       {{ define "repo/fragments/diffStatPill" }}

     

       2
        
         <div class="flex items-center font-mono text-sm">

     

       3
        
           {{ if and .Insertions .Deletions }}

     

       4
       +
             <span class="rounded-l p-1 select-none bg-green-100 text-green-700 dark:bg-green-800/50 dark:text-green-400">+{{ .Insertions }}</span>

     

       5
       +
             <span class="rounded-r p-1 select-none bg-red-100 text-red-700 dark:bg-red-800/50 dark:text-red-400">-{{ .Deletions }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
           {{ else if .Insertions }}

     

       7
       +
             <span class="rounded p-1 select-none bg-green-100 text-green-700 dark:bg-green-800/50 dark:text-green-400">+{{ .Insertions }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
           {{ else if .Deletions }}

     

       9
       +
             <span class="rounded p-1 select-none bg-red-100 text-red-700 dark:bg-red-800/50 dark:text-red-400">-{{ .Deletions }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
           {{ end }}

     

       11
        
         </div>

     

       12
        
       {{ end }}

     

       13
       +

+28 -21

appview/pages/templates/repo/fragments/reaction.html

···

       1
        
       {{ define "repo/fragments/reaction" }}

     

       2
       -
         <button

     

       3
       -
           id="reactIndi-{{ .Kind }}"

     

       4
       -
           class="flex justify-center items-center min-w-8 min-h-8 rounded border

     

       5
        
                   leading-4 px-3 gap-1

     

       6
        
                   {{ if eq .Count 0 }}

     

       7
       -
             hidden

     

       8
       -
           {{ end }}

     

       9
        
                   {{ if .IsReacted }}

     

       10
       -
             bg-sky-100 border-sky-400 dark:bg-sky-900 dark:border-sky-500

     

       11
       -
           {{ else }}

     

       12
       -
             border-gray-200 hover:bg-gray-50 hover:border-gray-300

     

       13
       -
             dark:border-gray-700 dark:hover:bg-gray-700 dark:hover:border-gray-600

     

       14
       -
           {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
                   "

     

       16
       -
           {{ if .IsReacted }}

     

       17
       -
             hx-delete="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}"

     

       18
       -
           {{ else }}

     

       19
       -
             hx-post="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}"

     

       20
       -
           {{ end }}

     

       21
       -
           hx-swap="outerHTML"

     

       22
       -
           hx-trigger="click from:(#reactBtn-{{ .Kind }}, #reactIndi-{{ .Kind }})"

     

       23
       -
           hx-disabled-elt="this">

     

       24
       -
           <span>{{ .Kind }}</span>

     

       25
       -
           <span>{{ .Count }}</span>

     

       26
       -
         </button>

     

       27
        
       {{ end }}

···

       1
        
       {{ define "repo/fragments/reaction" }}

     

       2
       +
           <button

     

       3
       +
               id="reactIndi-{{ .Kind }}"

     

       4
       +
               class="flex justify-center items-center min-w-8 min-h-8 rounded border

     

       5
        
                   leading-4 px-3 gap-1

     

       6
        
                   {{ if eq .Count 0 }}

     

       7
       +
                       hidden

     

       8
       +
                   {{ end }}

     

       9
        
                   {{ if .IsReacted }}

     

       10
       +
                       bg-sky-100

     

       11
       +
                       border-sky-400

     

       12
       +
                       dark:bg-sky-900

     

       13
       +
                       dark:border-sky-500

     

       14
       +
                   {{ else }}

     

       15
       +
                       border-gray-200

     

       16
       +
                       hover:bg-gray-50

     

       17
       +
                       hover:border-gray-300

     

       18
       +
                       dark:border-gray-700

     

       19
       +
                       dark:hover:bg-gray-700

     

       20
       +
                       dark:hover:border-gray-600

     

       21
       +
                   {{ end }}

     

       22
        
                   "

     

       23
       +
               {{ if .IsReacted }}

     

       24
       +
                   hx-delete="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}"

     

       25
       +
               {{ else }}

     

       26
       +
                   hx-post="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}"

     

       27
       +
               {{ end }}

     

       28
       +
               hx-swap="outerHTML"

     

       29
       +
               hx-trigger="click from:(#reactBtn-{{ .Kind }}, #reactIndi-{{ .Kind }})"

     

       30
       +
               hx-disabled-elt="this"

     

       31
       +
           >

     

       32
       +
               <span>{{ .Kind }}</span> <span>{{ .Count }}</span>

     

       33
       +
           </button>

     

       34
        
       {{ end }}

+24 -18

appview/pages/templates/repo/fragments/reactionsPopUp.html

···

       1
        
       {{ define "repo/fragments/reactionsPopUp" }}

     

       2
       -
         <details id="reactionsPopUp" class="relative inline-block">

     

       3
       -
           <summary

     

       4
       -
             class="flex justify-center items-center min-w-8 min-h-8 rounded border border-gray-200 dark:border-gray-700

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
                       hover:bg-gray-50

     

       6
        
                       hover:border-gray-300

     

       7
        
                       dark:hover:bg-gray-700

     

       8
        
                       dark:hover:border-gray-600

     

       9
       -
                       cursor-pointer list-none">

     

       10
       -
             {{ i "smile" "size-4" }}

     

       11
       -
           </summary>

     

       12
       -
           <div

     

       13
       -
             class="absolute flex left-0 z-10 mt-4 rounded bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700 shadow-lg">

     

       14
       -
             {{ range $kind := . }}

     

       15
       -
               <button

     

       16
       -
                 id="reactBtn-{{ $kind }}"

     

       17
       -
                 class="size-12 hover:bg-gray-100 dark:hover:bg-gray-700"

     

       18
       -
                 hx-on:click="this.parentElement.parentElement.removeAttribute('open')">

     

       19
       -
                 {{ $kind }}

     

       20
       -
               </button>

     

       21
       -
             {{ end }}

     

       22
       -
           </div>

     

       23
       -
         </details>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
       {{ end }}

···

       1
        
       {{ define "repo/fragments/reactionsPopUp" }}

     

       2
       +
           <details

     

       3
       +
               id="reactionsPopUp"

     

       4
       +
               class="relative inline-block"

     

       5
       +
           >

     

       6
       +
               <summary

     

       7
       +
                   class="flex justify-center items-center min-w-8 min-h-8 rounded border border-gray-200 dark:border-gray-700

     

       8
        
                       hover:bg-gray-50

     

       9
        
                       hover:border-gray-300

     

       10
        
                       dark:hover:bg-gray-700

     

       11
        
                       dark:hover:border-gray-600

     

       12
       +
                       cursor-pointer list-none"

     

       13
       +
               >

     

       14
       +
                   {{ i "smile" "size-4" }}

     

       15
       +
               </summary>

     

       16
       +
               <div

     

       17
       +
                   class="absolute flex left-0 z-10 mt-4 rounded bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700 shadow-lg"

     

       18
       +
               >

     

       19
       +
                   {{ range $kind := . }}

     

       20
       +
                       <button

     

       21
       +
                           id="reactBtn-{{ $kind }}"

     

       22
       +
                           class="size-12 hover:bg-gray-100 dark:hover:bg-gray-700"

     

       23
       +
                           hx-on:click="this.parentElement.parentElement.removeAttribute('open')"

     

       24
       +
                       >

     

       25
       +
                           {{ $kind }}

     

       26
       +
                       </button>

     

       27
       +
                   {{ end }}

     

       28
       +
               </div>

     

       29
       +
           </details>

     

       30
        
       {{ end }}

+23 -22

appview/pages/templates/repo/fragments/repoStar.html

···

       1
        
       {{ define "repo/fragments/repoStar" }}

     

       2
       -
         <button

     

       3
       -
           id="starBtn"

     

       4
       -
           class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       -
           {{ if .IsStarred }}

     

       6
       -
             hx-delete="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       7
       -
           {{ else }}

     

       8
       -
             hx-post="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       9
       -
           {{ end }}

     

       10
        
       

     

       11
       -
           hx-trigger="click"

     

       12
       -
           hx-target="this"

     

       13
       -
           hx-swap="outerHTML"

     

       14
       -
           hx-disabled-elt="#starBtn">

     

       15
       -
           {{ if .IsStarred }}

     

       16
       -
             {{ i "star" "w-4 h-4 fill-current" }}

     

       17
       -
           {{ else }}

     

       18
       -
             {{ i "star" "w-4 h-4" }}

     

       19
       -
           {{ end }}

     

       20
       -
           <span class="text-sm">

     

       21
       -
             {{ .Stats.StarCount }}

     

       22
       -
           </span>

     

       23
       -
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       24
       -
         </button>

     

       0
        
       
     

       25
        
       {{ end }}

···

       1
        
       {{ define "repo/fragments/repoStar" }}

     

       2
       +
           <button

     

       3
       +
               id="starBtn"

     

       4
       +
               class="btn disabled:opacity-50 disabled:cursor-not-allowed flex gap-2 items-center group"

     

       5
       +
               {{ if .IsStarred }}

     

       6
       +
                   hx-delete="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       7
       +
               {{ else }}

     

       8
       +
                   hx-post="/star?subject={{ .RepoAt }}&countHint={{ .Stats.StarCount }}"

     

       9
       +
               {{ end }}

     

       10
        
       

     

       11
       +
               hx-trigger="click"

     

       12
       +
               hx-target="this"

     

       13
       +
               hx-swap="outerHTML"

     

       14
       +
               hx-disabled-elt="#starBtn"

     

       15
       +
           >

     

       16
       +
               {{ if .IsStarred }}

     

       17
       +
                   {{ i "star" "w-4 h-4 fill-current" }}

     

       18
       +
               {{ else }}

     

       19
       +
                   {{ i "star" "w-4 h-4" }}

     

       20
       +
               {{ end }}

     

       21
       +
               <span class="text-sm">

     

       22
       +
                   {{ .Stats.StarCount }}

     

       23
       +
               </span>

     

       24
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       25
       +
           </button>

     

       26
        
       {{ end }}

+58 -113

appview/pages/templates/repo/fragments/splitDiff.html

···

       1
        
       {{ define "repo/fragments/splitDiff" }}

     

       2
       -
         {{ $name := .Id }}

     

       3
       -
         {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800" -}}

     

       4
       -
         {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}}

     

       5
       -
         {{- $lineNrSepStyle := "pr-2 border-r border-gray-200 dark:border-gray-700" -}}

     

       6
       -
         {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}}

     

       7
       -
         {{- $emptyStyle := "bg-gray-200/30 dark:bg-gray-700/30" -}}

     

       8
       -
         {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400" -}}

     

       9
       -
         {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}}

     

       10
       -
         {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}}

     

       11
       -
         {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}}

     

       12
       -
         <div class="grid grid-cols-2 divide-x divide-gray-200 dark:divide-gray-700">

     

       13
       -
           <pre

     

       14
       -
             class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}

     

       15
       -
             <div

     

       16
       -
               class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">

     

       17
       -
               &middot;&middot;&middot;

     

       18
       -
             </div>

     

       19
       -
             {{- range .LeftLines -}}

     

       20
       -
               {{- if .IsEmpty -}}

     

       21
       -
                 <div class="{{ $emptyStyle }} {{ $containerStyle }}">

     

       22
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       23
       -
                     <span aria-hidden="true" class="invisible">

     

       24
       -
                       {{ .LineNumber }}

     

       25
       -
                     </span>

     

       26
       -
                   </div>

     

       27
       -
                   <div class="{{ $opStyle }}">

     

       28
       -
                     <span aria-hidden="true" class="invisible">{{ .Op.String }}</span>

     

       29
       -
                   </div>

     

       30
       -
                   <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div>

     

       31
       -
                 </div>

     

       32
       -
               {{- else if eq .Op.String "-" -}}

     

       33
       -
                 <div

     

       34
       -
                   class="{{ $delStyle }} {{ $containerStyle }}"

     

       35
       -
                   id="{{ $name }}-O{{ .LineNumber }}">

     

       36
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       37
       -
                     <a

     

       38
       -
                       class="{{ $linkStyle }}"

     

       39
       -
                       href="#{{ $name }}-O{{ .LineNumber }}">

     

       40
       -
                       {{ .LineNumber }}

     

       41
       -
                     </a>

     

       42
       -
                   </div>

     

       43
       -
                   <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       44
       -
                   <div class="px-2">{{ .Content }}</div>

     

       45
       -
                 </div>

     

       46
       -
               {{- else if eq .Op.String " " -}}

     

       47
       -
                 <div

     

       48
       -
                   class="{{ $ctxStyle }} {{ $containerStyle }}"

     

       49
       -
                   id="{{ $name }}-O{{ .LineNumber }}">

     

       50
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       51
       -
                     <a

     

       52
       -
                       class="{{ $linkStyle }}"

     

       53
       -
                       href="#{{ $name }}-O{{ .LineNumber }}">

     

       54
       -
                       {{ .LineNumber }}

     

       55
       -
                     </a>

     

       56
       -
                   </div>

     

       57
       -
                   <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       58
       -
                   <div class="px-2">{{ .Content }}</div>

     

       59
       -
                 </div>

     

       60
       -
               {{- end -}}

     

       61
       -
             {{- end -}}

     

       62
       -
           {{- end -}}

     

       63
       -
           </div></div></pre>

     

       64
        
       

     

       65
       -
           <pre

     

       66
       -
             class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}

     

       67
       -
             <div

     

       68
       -
               class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">

     

       69
       -
               &middot;&middot;&middot;

     

       70
       -
             </div>

     

       71
       -
             {{- range .RightLines -}}

     

       72
       -
               {{- if .IsEmpty -}}

     

       73
       -
                 <div class="{{ $emptyStyle }} {{ $containerStyle }}">

     

       74
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       75
       -
                     <span aria-hidden="true" class="invisible">

     

       76
       -
                       {{ .LineNumber }}

     

       77
       -
                     </span>

     

       78
       -
                   </div>

     

       79
       -
                   <div class="{{ $opStyle }}">

     

       80
       -
                     <span aria-hidden="true" class="invisible">{{ .Op.String }}</span>

     

       81
       -
                   </div>

     

       82
       -
                   <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div>

     

       83
       -
                 </div>

     

       84
       -
               {{- else if eq .Op.String "+" -}}

     

       85
       -
                 <div

     

       86
       -
                   class="{{ $addStyle }} {{ $containerStyle }}"

     

       87
       -
                   id="{{ $name }}-N{{ .LineNumber }}">

     

       88
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       89
       -
                     <a

     

       90
       -
                       class="{{ $linkStyle }}"

     

       91
       -
                       href="#{{ $name }}-N{{ .LineNumber }}">

     

       92
       -
                       {{ .LineNumber }}

     

       93
       -
                     </a>

     

       94
       -
                   </div>

     

       95
       -
                   <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       96
       -
                   <div class="px-2">{{ .Content }}</div>

     

       97
       -
                 </div>

     

       98
       -
               {{- else if eq .Op.String " " -}}

     

       99
       -
                 <div

     

       100
       -
                   class="{{ $ctxStyle }} {{ $containerStyle }}"

     

       101
       -
                   id="{{ $name }}-N{{ .LineNumber }}">

     

       102
       -
                   <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}">

     

       103
       -
                     <a

     

       104
       -
                       class="{{ $linkStyle }}"

     

       105
       -
                       href="#{{ $name }}-N{{ .LineNumber }}">

     

       106
       -
                       {{ .LineNumber }}

     

       107
       -
                     </a>

     

       108
       -
                   </div>

     

       109
       -
                   <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       110
       -
                   <div class="px-2">{{ .Content }}</div>

     

       111
       -
                 </div>

     

       112
       -
               {{- end -}}

     

       113
       -
             {{- end -}}

     

       114
       -
           {{- end -}}</div></div></pre>

     

       115
       -
         </div>

     

       116
        
       {{ end }}

···

       1
        
       {{ define "repo/fragments/splitDiff" }}

     

       2
       +
       {{ $name := .Id }}

     

       3
       +
       {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800" -}}

     

       4
       +
       {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}}

     

       5
       +
       {{- $lineNrSepStyle := "pr-2 border-r border-gray-200 dark:border-gray-700" -}}

     

       6
       +
       {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}}

     

       7
       +
       {{- $emptyStyle := "bg-gray-200/30 dark:bg-gray-700/30" -}}

     

       8
       +
       {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400" -}}

     

       9
       +
       {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}}

     

       10
       +
       {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}}

     

       11
       +
       {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}}

     

       12
       +
       <div class="grid grid-cols-2 divide-x divide-gray-200 dark:divide-gray-700">

     

       13
       +
       <pre class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div>

     

       14
       +
        {{- range .LeftLines -}}

     

       15
       +
          {{- if .IsEmpty -}}

     

       16
       +
            <div class="{{ $emptyStyle }} {{ $containerStyle }}">

     

       17
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></div>

     

       18
       +
              <div class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></div>

     

       19
       +
              <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div>

     

       20
       +
            </div>

     

       21
       +
          {{- else if eq .Op.String "-" -}}

     

       22
       +
            <div class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}">

     

       23
       +
              <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></div>

     

       24
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       25
       +
              <div class="px-2">{{ .Content }}</div>

     

       26
       +
            </div>

     

       27
       +
          {{- else if eq .Op.String " " -}}

     

       28
       +
            <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{.LineNumber}}">

     

       29
       +
              <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle }}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{.LineNumber}}">{{ .LineNumber }}</a></div>

     

       30
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       31
       +
              <div class="px-2">{{ .Content }}</div>

     

       32
       +
            </div>

     

       33
       +
          {{- end -}}

     

       34
       +
        {{- end -}}

     

       35
       +
        {{- end -}}</div></div></pre>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       36
        
       

     

       37
       +
       <pre class="overflow-x-auto col-span-1"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div>

     

       38
       +
        {{- range .RightLines -}}

     

       39
       +
          {{- if .IsEmpty -}}

     

       40
       +
            <div class="{{ $emptyStyle }} {{ $containerStyle }}">

     

       41
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><span aria-hidden="true" class="invisible">{{.LineNumber}}</span></div>

     

       42
       +
              <div class="{{ $opStyle }}"><span aria-hidden="true" class="invisible">{{ .Op.String }}</span></div>

     

       43
       +
              <div class="px-2 invisible" aria-hidden="true">{{ .Content }}</div>

     

       44
       +
            </div>

     

       45
       +
          {{- else if eq .Op.String "+" -}}

     

       46
       +
            <div class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}">

     

       47
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a></div>

     

       48
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       49
       +
              <div class="px-2" >{{ .Content }}</div>

     

       50
       +
            </div>

     

       51
       +
          {{- else if eq .Op.String " " -}}

     

       52
       +
            <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-N{{.LineNumber}}">

     

       53
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{.LineNumber}}">{{ .LineNumber }}</a></div>

     

       54
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       55
       +
              <div class="px-2">{{ .Content }}</div>

     

       56
       +
            </div>

     

       57
       +
          {{- end -}}

     

       58
       +
        {{- end -}}

     

       59
       +
        {{- end -}}</div></div></pre>

     

       60
       +
       </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       61
        
       {{ end }}

+45 -79

appview/pages/templates/repo/fragments/unifiedDiff.html

···

       1
        
       {{ define "repo/fragments/unifiedDiff" }}

     

       2
       -
         {{ $name := .Id }}

     

       3
       -
         <pre

     

       4
       -
           class="overflow-x-auto"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}

     

       5
       -
           <div

     

       6
       -
             class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">

     

       7
       -
             &middot;&middot;&middot;

     

       8
       -
           </div>

     

       9
       -
           {{- $oldStart := .OldPosition -}}

     

       10
       -
           {{- $newStart := .NewPosition -}}

     

       11
       -
           {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800 target:bg-yellow-200 target:dark:bg-yellow-600" -}}

     

       12
       -
           {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}}

     

       13
       -
           {{- $lineNrSepStyle1 := "" -}}

     

       14
       -
           {{- $lineNrSepStyle2 := "pr-2 border-r border-gray-200 dark:border-gray-700" -}}

     

       15
       -
           {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}}

     

       16
       -
           {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400 " -}}

     

       17
       -
           {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}}

     

       18
       -
           {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}}

     

       19
       -
           {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}}

     

       20
       -
           {{- range .Lines -}}

     

       21
       -
             {{- if eq .Op.String "+" -}}

     

       22
       -
               <div

     

       23
       -
                 class="{{ $addStyle }} {{ $containerStyle }}"

     

       24
       -
                 id="{{ $name }}-N{{ $newStart }}">

     

       25
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle1 }}">

     

       26
       -
                   <span aria-hidden="true" class="invisible">{{ $newStart }}</span>

     

       27
       -
                 </div>

     

       28
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle2 }}">

     

       29
       -
                   <a class="{{ $linkStyle }}" href="#{{ $name }}-N{{ $newStart }}">

     

       30
       -
                     {{ $newStart }}

     

       31
       -
                   </a>

     

       32
       -
                 </div>

     

       33
       -
                 <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       34
       -
                 <div class="px-2">{{ .Line }}</div>

     

       35
       -
               </div>

     

       36
       -
               {{- $newStart = add64 $newStart 1 -}}

     

       37
       -
             {{- end -}}

     

       38
       -
             {{- if eq .Op.String "-" -}}

     

       39
       -
               <div

     

       40
       -
                 class="{{ $delStyle }} {{ $containerStyle }}"

     

       41
       -
                 id="{{ $name }}-O{{ $oldStart }}">

     

       42
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle1 }}">

     

       43
       -
                   <a class="{{ $linkStyle }}" href="#{{ $name }}-O{{ $oldStart }}">

     

       44
       -
                     {{ $oldStart }}

     

       45
       -
                   </a>

     

       46
       -
                 </div>

     

       47
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle2 }}">

     

       48
       -
                   <span aria-hidden="true" class="invisible">{{ $oldStart }}</span>

     

       49
       -
                 </div>

     

       50
       -
                 <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       51
       -
                 <div class="px-2">{{ .Line }}</div>

     

       52
       -
               </div>

     

       53
       -
               {{- $oldStart = add64 $oldStart 1 -}}

     

       54
       -
             {{- end -}}

     

       55
       -
             {{- if eq .Op.String " " -}}

     

       56
       -
               <div

     

       57
       -
                 class="{{ $ctxStyle }} {{ $containerStyle }}"

     

       58
       -
                 id="{{ $name }}-O{{ $oldStart }}-N{{ $newStart }}">

     

       59
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle1 }}">

     

       60
       -
                   <a

     

       61
       -
                     class="{{ $linkStyle }}"

     

       62
       -
                     href="#{{ $name }}-O{{ $oldStart }}-N{{ $newStart }}">

     

       63
       -
                     {{ $oldStart }}

     

       64
       -
                   </a>

     

       65
       -
                 </div>

     

       66
       -
                 <div class="{{ $lineNrStyle }} {{ $lineNrSepStyle2 }}">

     

       67
       -
                   <a

     

       68
       -
                     class="{{ $linkStyle }}"

     

       69
       -
                     href="#{{ $name }}-O{{ $oldStart }}-N{{ $newStart }}">

     

       70
       -
                     {{ $newStart }}

     

       71
       -
                   </a>

     

       72
       -
                 </div>

     

       73
       -
                 <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       74
       -
                 <div class="px-2">{{ .Line }}</div>

     

       75
       -
               </div>

     

       76
       -
               {{- $newStart = add64 $newStart 1 -}}

     

       77
       -
               {{- $oldStart = add64 $oldStart 1 -}}

     

       78
       -
             {{- end -}}

     

       79
       -
           {{- end -}}

     

       80
       -
         {{- end -}}</div></div></pre>

     

       81
        
       {{ end }}

     

       0

···

       1
        
       {{ define "repo/fragments/unifiedDiff" }}

     

       2
       +
       {{ $name := .Id }}

     

       3
       +
       <pre class="overflow-x-auto"><div class="overflow-x-auto"><div class="min-w-full inline-block">{{- range .TextFragments -}}<div class="bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 select-none text-center">&middot;&middot;&middot;</div>

     

       4
       +
        {{- $oldStart := .OldPosition -}}

     

       5
       +
        {{- $newStart := .NewPosition -}}

     

       6
       +
        {{- $lineNrStyle := "min-w-[3.5rem] flex-shrink-0 select-none text-right bg-white dark:bg-gray-800 target:bg-yellow-200 target:dark:bg-yellow-600" -}}

     

       7
       +
        {{- $linkStyle := "text-gray-400 dark:text-gray-500 hover:underline" -}}

     

       8
       +
        {{- $lineNrSepStyle1 := "" -}}

     

       9
       +
        {{- $lineNrSepStyle2 := "pr-2 border-r border-gray-200 dark:border-gray-700" -}}

     

       10
       +
        {{- $containerStyle := "flex min-w-full items-center target:border target:rounded-sm target:border-yellow-200 target:dark:border-yellow-700 scroll-mt-20" -}}

     

       11
       +
        {{- $addStyle := "bg-green-100 dark:bg-green-800/30 text-green-700 dark:text-green-400 " -}}

     

       12
       +
        {{- $delStyle := "bg-red-100 dark:bg-red-800/30 text-red-700 dark:text-red-400 " -}}

     

       13
       +
        {{- $ctxStyle := "bg-white dark:bg-gray-800 text-gray-500 dark:text-gray-400" -}}

     

       14
       +
        {{- $opStyle := "w-5 flex-shrink-0 select-none text-center" -}}

     

       15
       +
        {{- range .Lines -}}

     

       16
       +
          {{- if eq .Op.String "+" -}}

     

       17
       +
            <div class="{{ $addStyle }} {{ $containerStyle }}" id="{{$name}}-N{{$newStart}}">

     

       18
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><span aria-hidden="true" class="invisible">{{$newStart}}</span></div>

     

       19
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-N{{$newStart}}">{{ $newStart }}</a></div>

     

       20
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       21
       +
              <div class="px-2">{{ .Line }}</div>

     

       22
       +
            </div>

     

       23
       +
            {{- $newStart = add64 $newStart 1 -}}

     

       24
       +
          {{- end -}}

     

       25
       +
          {{- if eq .Op.String "-" -}}

     

       26
       +
            <div class="{{ $delStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}">

     

       27
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}">{{ $oldStart }}</a></div>

     

       28
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><span aria-hidden="true" class="invisible">{{$oldStart}}</span></div>

     

       29
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       30
       +
              <div class="px-2">{{ .Line }}</div>

     

       31
       +
            </div>

     

       32
       +
            {{- $oldStart = add64 $oldStart 1 -}}

     

       33
       +
          {{- end -}}

     

       34
       +
          {{- if eq .Op.String " " -}}

     

       35
       +
            <div class="{{ $ctxStyle }} {{ $containerStyle }}" id="{{$name}}-O{{$oldStart}}-N{{$newStart}}">

     

       36
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle1}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $oldStart }}</a></div>

     

       37
       +
              <div class="{{$lineNrStyle}} {{$lineNrSepStyle2}}"><a class="{{$linkStyle}}" href="#{{$name}}-O{{$oldStart}}-N{{$newStart}}">{{ $newStart }}</a></div>

     

       38
       +
              <div class="{{ $opStyle }}">{{ .Op.String }}</div>

     

       39
       +
              <div class="px-2">{{ .Line }}</div>

     

       40
       +
            </div>

     

       41
       +
            {{- $newStart = add64 $newStart 1 -}}

     

       42
       +
            {{- $oldStart = add64 $oldStart 1 -}}

     

       43
       +
          {{- end -}}

     

       44
       +
        {{- end -}}

     

       45
       +
        {{- end -}}</div></div></pre>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       46
        
       {{ end }}

     

       47
       +

+12 -21

appview/pages/templates/repo/pipelines/fragments/logBlock.html

···

       1
        
       {{ define "repo/pipelines/fragments/logBlock" }}

     

       2
       -
         <div id="lines" hx-swap-oob="beforeend">

     

       3
       -
           <details

     

       4
       -
             id="step-{{ .Id }}"

     

       5
       -
             {{ if not .Collapsed }}open{{ end }}

     

       6
       -
             class="group pb-2 rounded-sm border border-gray-200 dark:border-gray-700">

     

       7
       -
             <summary

     

       8
       -
               class="sticky top-0 pt-2 px-2 group-open:pb-2 group-open:mb-2 list-none cursor-pointer group-open:border-b border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:text-gray-500 hover:dark:text-gray-400">

     

       9
       -
               <div class="group-open:hidden flex items-center gap-1">

     

       10
       -
                 {{ i "chevron-right" "w-4 h-4" }}

     

       11
       -
                 {{ .Name }}

     

       12
       -
               </div>

     

       13
       -
               <div class="hidden group-open:flex items-center gap-1">

     

       14
       -
                 {{ i "chevron-down" "w-4 h-4" }}

     

       15
       -
                 {{ .Name }}

     

       16
       -
               </div>

     

       17
       -
             </summary>

     

       18
       -
             <div class="font-mono whitespace-pre overflow-x-auto px-2">

     

       19
       -
               <div class="text-blue-600 dark:text-blue-300">{{ .Command }}</div>

     

       20
       -
               <div id="step-body-{{ .Id }}"></div>

     

       21
        
             </div>

     

       22
       -
           </details>

     

       23
       -
         </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
       {{ end }}

···

       1
        
       {{ define "repo/pipelines/fragments/logBlock" }}

     

       2
       +
       <div id="lines" hx-swap-oob="beforeend">

     

       3
       +
         <details id="step-{{ .Id }}" {{if not .Collapsed}}open{{end}} class="group pb-2 rounded-sm border border-gray-200 dark:border-gray-700">

     

       4
       +
           <summary class="sticky top-0 pt-2 px-2 group-open:pb-2 group-open:mb-2 list-none cursor-pointer group-open:border-b border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:text-gray-500 hover:dark:text-gray-400">

     

       5
       +
             <div class="group-open:hidden flex items-center gap-1">

     

       6
       +
               {{ i "chevron-right" "w-4 h-4" }} {{ .Name }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
             </div>

     

       8
       +
             <div class="hidden group-open:flex items-center gap-1">

     

       9
       +
               {{ i "chevron-down" "w-4 h-4" }} {{ .Name }}

     

       10
       +
             </div>

     

       11
       +
           </summary>

     

       12
       +
           <div class="font-mono whitespace-pre overflow-x-auto px-2"><div class="text-blue-600 dark:text-blue-300">{{ .Command }}</div><div id="step-body-{{ .Id }}"></div></div>

     

       13
       +
         </details>

     

       14
       +
       </div>

     

       15
        
       {{ end }}

+63 -62

appview/pages/templates/repo/pulls/fragments/pullActions.html

···

       23
        
         {{ $isSameRepoBranch := .Pull.IsBranchBased }}

     

       24
        
         {{ $isUpToDate := .ResubmitCheck.No }}

     

       25
        
         <div class="relative w-fit">

     

       26
       -
           <div id="actions-{{ $roundNumber }}" class="flex flex-wrap gap-2">

     

       27
       -
             <button

     

       28
       -
               hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       29
       -
               hx-target="#actions-{{ $roundNumber }}"

     

       30
       -
               hx-swap="outerHtml"

     

       31
       -
               class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       32
       -
               {{ i "message-square-plus" "w-4 h-4" }}

     

       33
       -
               <span>comment</span>

     

       34
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       35
       -
             </button>

     

       36
       -
             {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       37
       -
               {{ $disabled := "" }}

     

       38
       -
               {{ if $isConflicted }}

     

       39
       -
                 {{ $disabled = "disabled" }}

     

       40
       -
               {{ end }}

     

       41
       -
               <button

     

       42
       -
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       43
       -
                 hx-swap="none"

     

       44
       -
                 hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       45
       -
                 class="btn p-2 flex items-center gap-2 group"

     

       46
       -
                 {{ $disabled }}>

     

       47
       -
                 {{ i "git-merge" "w-4 h-4" }}

     

       48
       -
                 <span>merge{{ if $stackCount }}{{ $stackCount }}{{ end }}</span>

     

       49
       -
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       50
        
               </button>

     

       51
       -
             {{ end }}

     

       52
       -
       

     

       53
       -
             {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       54
       -
               {{ $disabled := "" }}

     

       55
       -
               {{ if $isUpToDate }}

     

       56
       -
                 {{ $disabled = "disabled" }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       57
        
               {{ end }}

     

       58
       -
               <button

     

       59
       -
                 id="resubmitBtn"

     

       60
       -
                 {{ if not .Pull.IsPatchBased }}

     

       61
       -
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       62
       -
                 {{ else }}

     

       63
       -
                   hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       64
       -
                   hx-target="#actions-{{ $roundNumber }}" hx-swap="outerHtml"

     

       65
        
                 {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
       

     

       67
       -
                 hx-disabled-elt="#resubmitBtn"

     

       68
       -
                 class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group"

     

       69
       -
                 {{ $disabled }}

     

       70
        
       

     

       71
       -
                 {{ if $disabled }}

     

       72
       -
                   title="Update this branch to resubmit this pull request"

     

       73
       -
                 {{ else }}

     

       74
       -
                   title="Resubmit this pull request"

     

       75
       -
                 {{ end }}>

     

       76
       -
                 {{ i "rotate-ccw" "w-4 h-4" }}

     

       77
       -
                 <span>resubmit</span>

     

       78
       -
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       79
       -
               </button>

     

       80
       -
             {{ end }}

     

       0
        
       
     

       81
        
       

     

       82
       -
             {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       83
       -
               <button

     

       84
        
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       85
        
                 hx-swap="none"

     

       86
        
                 class="btn p-2 flex items-center gap-2 group">

     

       87
       -
                 {{ i "ban" "w-4 h-4" }}

     

       88
       -
                 <span>close</span>

     

       89
       -
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       90
        
               </button>

     

       91
       -
             {{ end }}

     

       92
        
       

     

       93
       -
             {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       94
       -
               <button

     

       95
        
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       96
        
                 hx-swap="none"

     

       97
        
                 class="btn p-2 flex items-center gap-2 group">

     

       98
       -
                 {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       99
       -
                 <span>reopen</span>

     

       100
       -
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       101
        
               </button>

     

       102
       -
             {{ end }}

     

       103
        
           </div>

     

       104
        
         </div>

     

       105
        
       {{ end }}

     

       0
        
       
     

       0

···

       23
        
         {{ $isSameRepoBranch := .Pull.IsBranchBased }}

     

       24
        
         {{ $isUpToDate := .ResubmitCheck.No }}

     

       25
        
         <div class="relative w-fit">

     

       26
       +
           <div id="actions-{{$roundNumber}}" class="flex flex-wrap gap-2">

     

       27
       +
               <button 

     

       28
       +
                 hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ $roundNumber }}/comment"

     

       29
       +
                 hx-target="#actions-{{$roundNumber}}"

     

       30
       +
                 hx-swap="outerHtml"

     

       31
       +
                 class="btn p-2 flex items-center gap-2 no-underline hover:no-underline group">

     

       32
       +
                   {{ i "message-square-plus" "w-4 h-4" }}

     

       33
       +
                   <span>comment</span>

     

       34
       +
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
               </button>

     

       36
       +
               {{ if and $isPushAllowed $isOpen $isLastRound }}

     

       37
       +
                 {{ $disabled := "" }}

     

       38
       +
                 {{ if $isConflicted }}

     

       39
       +
                   {{ $disabled = "disabled" }}

     

       40
       +
                 {{ end }}

     

       41
       +
                 <button 

     

       42
       +
                   hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/merge"

     

       43
       +
                   hx-swap="none"

     

       44
       +
                   hx-confirm="Are you sure you want to merge pull #{{ .Pull.PullId }} into the `{{ .Pull.TargetBranch }}` branch?"

     

       45
       +
                   class="btn p-2 flex items-center gap-2 group" {{ $disabled }}>

     

       46
       +
                   {{ i "git-merge" "w-4 h-4" }}

     

       47
       +
                   <span>merge{{if $stackCount}} {{$stackCount}}{{end}}</span>

     

       48
       +
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       49
       +
                 </button>

     

       50
        
               {{ end }}

     

       51
       +
       

     

       52
       +
               {{ if and $isPullAuthor $isOpen $isLastRound }}

     

       53
       +
                 {{ $disabled := "" }}

     

       54
       +
                 {{ if $isUpToDate }}

     

       55
       +
                   {{ $disabled = "disabled" }}

     

       0
        
       
     

       0
        
       
     

       56
        
                 {{ end }}

     

       57
       +
                 <button id="resubmitBtn"

     

       58
       +
                     {{ if not .Pull.IsPatchBased }}

     

       59
       +
                       hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       60
       +
                     {{ else }}

     

       61
       +
                       hx-get="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/resubmit"

     

       62
       +
                       hx-target="#actions-{{$roundNumber}}"

     

       63
       +
                       hx-swap="outerHtml"

     

       64
       +
                     {{ end }}

     

       65
        
       

     

       66
       +
                     hx-disabled-elt="#resubmitBtn"

     

       67
       +
                     class="btn p-2 flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed group" {{ $disabled }}

     

       0
        
       
     

       68
        
       

     

       69
       +
                     {{ if $disabled }}

     

       70
       +
                     title="Update this branch to resubmit this pull request"

     

       71
       +
                     {{ else }}

     

       72
       +
                     title="Resubmit this pull request"

     

       73
       +
                     {{ end }}

     

       74
       +
                     >

     

       75
       +
                     {{ i "rotate-ccw" "w-4 h-4" }}

     

       76
       +
                     <span>resubmit</span>

     

       77
       +
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       78
       +
                 </button>

     

       79
       +
               {{ end }}

     

       80
        
       

     

       81
       +
               {{ if and (or $isPullAuthor $isPushAllowed) $isOpen $isLastRound }}

     

       82
       +
               <button 

     

       83
        
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/close"

     

       84
        
                 hx-swap="none"

     

       85
        
                 class="btn p-2 flex items-center gap-2 group">

     

       86
       +
                   {{ i "ban" "w-4 h-4" }}

     

       87
       +
                   <span>close</span>

     

       88
       +
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       89
        
               </button>

     

       90
       +
               {{ end }}

     

       91
        
       

     

       92
       +
               {{ if and (or $isPullAuthor $isPushAllowed) $isClosed $isLastRound }}

     

       93
       +
               <button 

     

       94
        
                 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/reopen"

     

       95
        
                 hx-swap="none"

     

       96
        
                 class="btn p-2 flex items-center gap-2 group">

     

       97
       +
                   {{ i "refresh-ccw-dot" "w-4 h-4" }}

     

       98
       +
                   <span>reopen</span>

     

       99
       +
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       100
        
               </button>

     

       101
       +
               {{ end }}

     

       102
        
           </div>

     

       103
        
         </div>

     

       104
        
       {{ end }}

     

       105
       +
       

     

       106
       +

+39 -42

appview/pages/templates/repo/pulls/fragments/pullCompareBranches.html

···

       1
        
       {{ define "repo/pulls/fragments/pullCompareBranches" }}

     

       2
       -
         <div id="patch-upload">

     

       3
       -
           <label for="targetBranch" class="dark:text-white">

     

       4
       -
             select a source branch

     

       5
       -
           </label>

     

       6
       -
           <div class="flex flex-wrap gap-2 items-center">

     

       7
       -
             <select

     

       8
       -
               name="sourceBranch"

     

       9
       -
               class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600">

     

       10
       -
               <option disabled selected>source branch</option>

     

       11
        
       

     

       12
       -
               {{ $recent := index .Branches 0 }}

     

       13
       -
               {{ range .Branches }}

     

       14
       -
                 {{ $isRecent := eq .Reference.Name $recent.Reference.Name }}

     

       15
       -
                 {{ $preset := false }}

     

       16
       -
                 {{ if $.SourceBranch }}

     

       17
       -
                   {{ $preset = eq .Reference.Name $.SourceBranch }}

     

       18
       -
                 {{ else }}

     

       19
       -
                   {{ $preset = $isRecent }}

     

       20
       -
                 {{ end }}

     

       21
       -
       

     

       22
       -
       

     

       23
       -
                 <option

     

       24
       -
                   value="{{ .Reference.Name }}"

     

       25
       -
                   {{ if $preset }}

     

       26
       -
                     selected

     

       27
       -
                   {{ end }}

     

       28
       -
                   class="py-1">

     

       29
       -
                   {{ .Reference.Name }}

     

       30
       -
                   {{ if $isRecent }}(new){{ end }}

     

       31
       -
                 </option>

     

       32
       -
               {{ end }}

     

       33
       -
             </select>

     

       0
        
       
     

       34
        
           </div>

     

       35
       -
         </div>

     

       36
        
       

     

       37
       -
         <div class="flex items-center gap-2">

     

       38
       -
           <input type="checkbox" id="isStacked" name="isStacked" value="on" />

     

       39
       -
           <label for="isStacked" class="my-0 py-0 normal-case font-normal">

     

       40
       -
             Submit as stacked PRs

     

       41
       -
           </label>

     

       42
       -
         </div>

     

       43
        
       

     

       44
       -
         <p class="mt-4">

     

       45
       -
           Title and description are optional; if left out, they will be extracted from

     

       46
       -
           the first commit.

     

       47
       -
         </p>

     

       48
        
       {{ end }}

···

       1
        
       {{ define "repo/pulls/fragments/pullCompareBranches" }}

     

       2
       +
           <div id="patch-upload">

     

       3
       +
               <label for="targetBranch" class="dark:text-white">select a source branch</label>

     

       4
       +
               <div class="flex flex-wrap gap-2 items-center">

     

       5
       +
                   <select

     

       6
       +
                       name="sourceBranch"

     

       7
       +
                       class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       8
       +
                   >

     

       9
       +
                       <option disabled selected>source branch</option>

     

       0
        
       
     

       10
        
       

     

       11
       +
                       {{ $recent := index .Branches 0 }}

     

       12
       +
                       {{ range .Branches }}

     

       13
       +
                           {{ $isRecent := eq .Reference.Name $recent.Reference.Name }}

     

       14
       +
                           {{ $preset := false }}

     

       15
       +
                           {{ if $.SourceBranch }}

     

       16
       +
                               {{ $preset = eq .Reference.Name $.SourceBranch }}

     

       17
       +
                           {{ else }}

     

       18
       +
                               {{ $preset = $isRecent }}

     

       19
       +
                           {{ end }}

     

       20
       +
                           

     

       21
       +
                           <option

     

       22
       +
                               value="{{ .Reference.Name }}"

     

       23
       +
                               {{ if $preset }}

     

       24
       +
                                   selected

     

       25
       +
                               {{ end }}

     

       26
       +
                               class="py-1"

     

       27
       +
                           >

     

       28
       +
                               {{ .Reference.Name }}

     

       29
       +
                               {{ if $isRecent }}(new){{ end }}

     

       30
       +
                           </option>

     

       31
       +
                       {{ end }}

     

       32
       +
                   </select>

     

       33
       +
               </div>

     

       34
        
           </div>

     

       0
        
       
     

       35
        
       

     

       36
       +
           <div class="flex items-center gap-2">

     

       37
       +
             <input type="checkbox" id="isStacked" name="isStacked" value="on">

     

       38
       +
             <label for="isStacked" class="my-0 py-0 normal-case font-normal">Submit as stacked PRs</label>

     

       39
       +
           </div>

     

       0
        
       
     

       0
        
       
     

       40
        
       

     

       41
       +
           <p class="mt-4">

     

       42
       +
               Title and description are optional; if left out, they will be extracted

     

       43
       +
               from the first commit.

     

       44
       +
           </p>

     

       45
        
       {{ end }}

+22 -20

appview/pages/templates/repo/pulls/fragments/pullCompareForksBranches.html

···

       1
        
       {{ define "repo/pulls/fragments/pullCompareForksBranches" }}

     

       2
       -
         <div class="flex flex-wrap gap-2 items-center">

     

       3
       -
           <select

     

       4
       -
             name="sourceBranch"

     

       5
       -
             class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600">

     

       6
       -
             <option disabled selected>source branch</option>

     

       0
        
       
     

       7
        
       

     

       8
       -
             {{ $recent := index .SourceBranches 0 }}

     

       9
       -
             {{ range .SourceBranches }}

     

       10
       -
               {{ $isRecent := eq .Reference.Name $recent.Reference.Name }}

     

       11
       -
               <option

     

       12
       -
                 value="{{ .Reference.Name }}"

     

       13
       -
                 {{ if $isRecent }}

     

       14
       -
                   selected

     

       15
       -
                 {{ end }}

     

       16
       -
                 class="py-1">

     

       17
       -
                 {{ .Reference.Name }}

     

       18
       -
                 {{ if $isRecent }}(new){{ end }}

     

       19
       -
               </option>

     

       20
       -
             {{ end }}

     

       21
       -
           </select>

     

       22
       -
         </div>

     

       0
        
       
     

       23
        
       {{ end }}

···

       1
        
       {{ define "repo/pulls/fragments/pullCompareForksBranches" }}

     

       2
       +
           <div class="flex flex-wrap gap-2 items-center">

     

       3
       +
               <select

     

       4
       +
                   name="sourceBranch"

     

       5
       +
                   class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       6
       +
               >

     

       7
       +
                   <option disabled selected>source branch</option>

     

       8
        
       

     

       9
       +
                   {{ $recent := index .SourceBranches 0 }}

     

       10
       +
                   {{ range .SourceBranches }}

     

       11
       +
                       {{ $isRecent := eq .Reference.Name $recent.Reference.Name }}

     

       12
       +
                       <option

     

       13
       +
                           value="{{ .Reference.Name }}"

     

       14
       +
                           {{ if $isRecent }}

     

       15
       +
                               selected

     

       16
       +
                           {{ end }}

     

       17
       +
                           class="py-1"

     

       18
       +
                       >

     

       19
       +
                           {{ .Reference.Name }}

     

       20
       +
                           {{ if $isRecent }}(new){{ end }}

     

       21
       +
                       </option>

     

       22
       +
                   {{ end }}

     

       23
       +
               </select>

     

       24
       +
           </div>

     

       25
        
       {{ end }}

appview/pages/templates/repo/pulls/fragments/summarizedPullState.html

···

       17
        
       

     

       18
        
         {{ i $icon $style }}

     

       19
        
       {{ end }}

     

       0

···

       17
        
       

     

       18
        
         {{ i $icon $style }}

     

       19
        
       {{ end }}

     

       20
       +

+146 -136

appview/pages/templates/repo/pulls/new.html

···

       1
        
       {{ define "title" }}new pull &middot; {{ .RepoInfo.FullName }}{{ end }}

     

       2
        
       

     

       3
        
       {{ define "repoContent" }}

     

       4
       -
         <h2 class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       5
       -
           Create new pull request

     

       6
       -
         </h2>

     

       7
       -
       

     

       8
       -
         <form

     

       9
       -
           hx-post="/{{ .RepoInfo.FullName }}/pulls/new"

     

       10
       -
           hx-indicator="#create-pull-spinner"

     

       11
       -
           hx-swap="none">

     

       12
       -
           <div class="flex flex-col gap-6">

     

       13
       -
             <div class="flex gap-2 items-center">

     

       14
       -
               <p>First, choose a target branch on {{ .RepoInfo.FullName }}:</p>

     

       15
       -
               <div>

     

       16
       -
                 <select

     

       17
       -
                   required

     

       18
       -
                   name="targetBranch"

     

       19
       -
                   class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600">

     

       20
       -
                   <option disabled selected>target branch</option>

     

       21
       -
       

     

       22
       -
                   {{ range .Branches }}

     

       23
       -
                     {{ $preset := false }}

     

       24
       -
                     {{ if $.TargetBranch }}

     

       25
       -
                       {{ $preset = eq .Reference.Name $.TargetBranch }}

     

       26
       -
                     {{ else }}

     

       27
       -
                       {{ $preset = .IsDefault }}

     

       28
       -
                     {{ end }}

     

       29
       -
       

     

       30
       -
       

     

       31
       -
                     <option

     

       32
       -
                       value="{{ .Reference.Name }}"

     

       33
       -
                       class="py-1"

     

       34
       -
                       {{ if $preset }}selected{{ end }}>

     

       35
       -
                       {{ .Reference.Name }}

     

       36
       -
                     </option>

     

       37
       -
                   {{ end }}

     

       38
       -
                 </select>

     

       39
       -
               </div>

     

       40
       -
             </div>

     

       41
       -
       

     

       42
       -
             <div class="flex flex-col gap-2">

     

       43
       -
               <h2 class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       44
       -
                 Choose pull strategy

     

       45
       -
               </h2>

     

       46
       -
               <nav class="flex space-x-4 items-center">

     

       47
       -
                 <button

     

       48
       -
                   type="button"

     

       49
       -
                   class="btn"

     

       50
       -
                   hx-get="/{{ .RepoInfo.FullName }}/pulls/new/patch-upload"

     

       51
       -
                   hx-target="#patch-strategy"

     

       52
       -
                   hx-swap="innerHTML">

     

       53
       -
                   paste patch

     

       54
       -
                 </button>

     

       55
       -
       

     

       56
       -
                 {{ if .RepoInfo.Roles.IsPushAllowed }}

     

       57
       -
                   <span class="text-sm text-gray-500 dark:text-gray-400">or</span>

     

       58
       -
                   <button

     

       59
       -
                     type="button"

     

       60
       -
                     class="btn"

     

       61
       -
                     hx-get="/{{ .RepoInfo.FullName }}/pulls/new/compare-branches"

     

       62
       -
                     hx-target="#patch-strategy"

     

       63
       -
                     hx-swap="innerHTML">

     

       64
       -
                     compare branches

     

       65
       -
                   </button>

     

       66
       -
                 {{ end }}

     

       67
       -
       

     

       68
       -
       

     

       69
       -
                 <span class="text-sm text-gray-500 dark:text-gray-400">or</span>

     

       70
       -
                 <script>

     

       71
       -
                   function getQueryParams() {

     

       72
       -
                     return Object.fromEntries(

     

       73
       -
                       new URLSearchParams(window.location.search),

     

       74
       -
                     );

     

       75
       -
                   }

     

       76
       -
                 </script>

     

       77
       -
                 <!--

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78
        
                         since compare-forks need the server to load forks, we

     

       79
        
                         hx-get this button; unlike simply loading the pullCompareForks template

     

       80
        
                         as we do for the rest of the gang below. the hx-vals thing just populates

     

       81
        
                         the query params so the forks page gets it.

     

       82
        
                         -->

     

       83
       -
                 <button

     

       84
       -
                   type="button"

     

       85
       -
                   class="btn"

     

       86
       -
                   hx-get="/{{ .RepoInfo.FullName }}/pulls/new/compare-forks"

     

       87
       -
                   hx-target="#patch-strategy"

     

       88
       -
                   hx-swap="innerHTML"

     

       89
       -
                   {{ if eq .Strategy "fork" }}

     

       90
       -
                     hx-trigger="click, load" hx-vals='js:{...getQueryParams()}'

     

       91
       -
                   {{ end }}>

     

       92
       -
                   compare forks

     

       93
       -
                 </button>

     

       94
       -
               </nav>

     

       95
       -
               <section id="patch-strategy" class="flex flex-col gap-2">

     

       96
       -
                 {{ if eq .Strategy "patch" }}

     

       97
       -
                   {{ template "repo/pulls/fragments/pullPatchUpload" . }}

     

       98
       -
                 {{ else if eq .Strategy "branch" }}

     

       99
       -
                   {{ template "repo/pulls/fragments/pullCompareBranches" . }}

     

       100
       -
                 {{ else }}

     

       101
       -
                   {{ template "repo/pulls/fragments/pullPatchUpload" . }}

     

       102
       -
                 {{ end }}

     

       103
       -
               </section>

     

       104
       -
       

     

       105
       -
               <div id="patch-error" class="error dark:text-red-300"></div>

     

       106
       -
             </div>

     

       107
       -
       

     

       108
       -
             <div>

     

       109
       -
               <label for="title" class="dark:text-white">write a title</label>

     

       110
       -
       

     

       111
       -
               <input

     

       112
       -
                 type="text"

     

       113
       -
                 name="title"

     

       114
       -
                 id="title"

     

       115
       -
                 value="{{ .Title }}"

     

       116
       -
                 class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       117
       -
                 placeholder="One-line summary of your change." />

     

       118
       -
             </div>

     

       119
       -
       

     

       120
       -
             <div>

     

       121
       -
               <label for="body" class="dark:text-white">add a description</label>

     

       122
       -
       

     

       123
       -
               <textarea

     

       124
       -
                 name="body"

     

       125
       -
                 id="body"

     

       126
       -
                 rows="6"

     

       127
       -
                 class="w-full resize-y dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       128
       -
                 placeholder="Describe your change. Markdown is supported.">

     

       129
       -
       {{ .Body }}</textarea

     

       130
       -
               >

     

       131
       -
             </div>

     

       132
       -
       

     

       133
       -
             <div class="flex justify-start items-center gap-2 mt-4">

     

       134
       -
               <button type="submit" class="btn-create flex items-center gap-2">

     

       135
       -
                 {{ i "git-pull-request-create" "w-4 h-4" }}

     

       136
       -
                 create pull

     

       137
       -
                 <span id="create-pull-spinner" class="group">

     

       138
       -
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       139
       -
                 </span>

     

       140
       -
               </button>

     

       141
       -
             </div>

     

       142
       -
           </div>

     

       143
       -
           <div id="pull" class="error dark:text-red-300"></div>

     

       144
       -
         </form>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       145
        
       {{ end }}

···

       1
        
       {{ define "title" }}new pull &middot; {{ .RepoInfo.FullName }}{{ end }}

     

       2
        
       

     

       3
        
       {{ define "repoContent" }}

     

       4
       +
           <h2 class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       5
       +
               Create new pull request

     

       6
       +
           </h2>

     

       7
       +
       

     

       8
       +
           <form

     

       9
       +
               hx-post="/{{ .RepoInfo.FullName }}/pulls/new"

     

       10
       +
               hx-indicator="#create-pull-spinner"

     

       11
       +
               hx-swap="none"

     

       12
       +
           >

     

       13
       +
               <div class="flex flex-col gap-6">

     

       14
       +
                   <div class="flex gap-2 items-center">

     

       15
       +
                     <p>First, choose a target branch on {{ .RepoInfo.FullName }}:</p>

     

       16
       +
                     <div>

     

       17
       +
                       <select

     

       18
       +
                         required

     

       19
       +
                         name="targetBranch"

     

       20
       +
                         class="p-1 border border-gray-200 bg-white dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       21
       +
                         >

     

       22
       +
                         <option disabled selected>target branch</option>

     

       23
       +
       

     

       24
       +
       

     

       25
       +
                         {{ range .Branches }}

     

       26
       +
       

     

       27
       +
                         {{ $preset := false }}

     

       28
       +
                         {{ if $.TargetBranch }}

     

       29
       +
                           {{ $preset = eq .Reference.Name $.TargetBranch }}

     

       30
       +
                         {{ else }}

     

       31
       +
                           {{ $preset = .IsDefault }}

     

       32
       +
                         {{ end }}

     

       33
       +
       

     

       34
       +
                         <option value="{{ .Reference.Name }}" class="py-1" {{if $preset}}selected{{end}}>

     

       35
       +
                         {{ .Reference.Name }}

     

       36
       +
                         </option>

     

       37
       +
                         {{ end }}

     

       38
       +
                       </select>

     

       39
       +
                     </div>

     

       40
       +
                   </div>

     

       41
       +
       

     

       42
       +
                   <div class="flex flex-col gap-2">

     

       43
       +
                     <h2 class="font-bold text-sm mb-4 uppercase dark:text-white">

     

       44
       +
                         Choose pull strategy

     

       45
       +
                     </h2>

     

       46
       +
                     <nav class="flex space-x-4 items-center">

     

       47
       +
                         <button

     

       48
       +
                             type="button"

     

       49
       +
                             class="btn"

     

       50
       +
                             hx-get="/{{ .RepoInfo.FullName }}/pulls/new/patch-upload"

     

       51
       +
                             hx-target="#patch-strategy"

     

       52
       +
                             hx-swap="innerHTML"

     

       53
       +
                         >

     

       54
       +
                             paste patch

     

       55
       +
                         </button>

     

       56
       +
       

     

       57
       +
                         {{ if .RepoInfo.Roles.IsPushAllowed }}

     

       58
       +
                             <span class="text-sm text-gray-500 dark:text-gray-400">

     

       59
       +
                                 or

     

       60
       +
                             </span>

     

       61
       +
                             <button

     

       62
       +
                                 type="button"

     

       63
       +
                                 class="btn"

     

       64
       +
                                 hx-get="/{{ .RepoInfo.FullName }}/pulls/new/compare-branches"

     

       65
       +
                                 hx-target="#patch-strategy"

     

       66
       +
                                 hx-swap="innerHTML"

     

       67
       +
                             >

     

       68
       +
                                 compare branches

     

       69
       +
                             </button>

     

       70
       +
                         {{ end }}

     

       71
       +
       

     

       72
       +
       

     

       73
       +
                         <span class="text-sm text-gray-500 dark:text-gray-400">

     

       74
       +
                             or

     

       75
       +
                         </span>

     

       76
       +
                         <script>

     

       77
       +
                           function getQueryParams() {

     

       78
       +
                             return Object.fromEntries(new URLSearchParams(window.location.search));

     

       79
       +
                           }

     

       80
       +
                         </script>

     

       81
       +
                         <!--

     

       82
        
                         since compare-forks need the server to load forks, we

     

       83
        
                         hx-get this button; unlike simply loading the pullCompareForks template

     

       84
        
                         as we do for the rest of the gang below. the hx-vals thing just populates

     

       85
        
                         the query params so the forks page gets it.

     

       86
        
                         -->

     

       87
       +
                         <button

     

       88
       +
                             type="button"

     

       89
       +
                             class="btn"

     

       90
       +
                             hx-get="/{{ .RepoInfo.FullName }}/pulls/new/compare-forks"

     

       91
       +
                             hx-target="#patch-strategy"

     

       92
       +
                             hx-swap="innerHTML"

     

       93
       +
                             {{ if eq .Strategy "fork" }}

     

       94
       +
                             hx-trigger="click, load"

     

       95
       +
                             hx-vals='js:{...getQueryParams()}'

     

       96
       +
                             {{ end }}

     

       97
       +
                         >

     

       98
       +
                             compare forks

     

       99
       +
                         </button>

     

       100
       +
       

     

       101
       +
       

     

       102
       +
                     </nav>

     

       103
       +
                     <section id="patch-strategy" class="flex flex-col gap-2">

     

       104
       +
                         {{ if eq .Strategy "patch" }}

     

       105
       +
                           {{ template "repo/pulls/fragments/pullPatchUpload" . }}

     

       106
       +
                         {{ else if eq .Strategy "branch" }}

     

       107
       +
                           {{ template "repo/pulls/fragments/pullCompareBranches" . }}

     

       108
       +
                         {{ else }}

     

       109
       +
                           {{ template "repo/pulls/fragments/pullPatchUpload" . }}

     

       110
       +
                         {{ end }}

     

       111
       +
                     </section>

     

       112
       +
       

     

       113
       +
                     <div id="patch-error" class="error dark:text-red-300"></div>

     

       114
       +
                   </div>

     

       115
       +
       

     

       116
       +
                   <div>

     

       117
       +
                       <label for="title" class="dark:text-white">write a title</label>

     

       118
       +
       

     

       119
       +
                       <input

     

       120
       +
                           type="text"

     

       121
       +
                           name="title"

     

       122
       +
                           id="title"

     

       123
       +
                           value="{{ .Title }}"

     

       124
       +
                           class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       125
       +
                           placeholder="One-line summary of your change."

     

       126
       +
                       />

     

       127
       +
                   </div>

     

       128
       +
       

     

       129
       +
                   <div>

     

       130
       +
                       <label for="body" class="dark:text-white"

     

       131
       +
                           >add a description</label

     

       132
       +
                       >

     

       133
       +
       

     

       134
       +
                       <textarea

     

       135
       +
                           name="body"

     

       136
       +
                           id="body"

     

       137
       +
                           rows="6"

     

       138
       +
                           class="w-full resize-y dark:bg-gray-700 dark:text-white dark:border-gray-600"

     

       139
       +
                           placeholder="Describe your change. Markdown is supported."

     

       140
       +
                       >{{ .Body }}</textarea>

     

       141
       +
                   </div>

     

       142
       +
       

     

       143
       +
                   <div class="flex justify-start items-center gap-2 mt-4">

     

       144
       +
                       <button type="submit" class="btn-create flex items-center gap-2">

     

       145
       +
                           {{ i "git-pull-request-create" "w-4 h-4" }}

     

       146
       +
                           create pull

     

       147
       +
                           <span id="create-pull-spinner" class="group">

     

       148
       +
                             {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       149
       +
                           </span>

     

       150
       +
                       </button>

     

       151
       +
                   </div>

     

       152
       +
               </div>

     

       153
       +
               <div id="pull" class="error dark:text-red-300"></div>

     

       154
       +
           </form>

     

       155
        
       {{ end }}

+8 -15

appview/pages/templates/repo/settings/fragments/secretListing.html

···

       1
        
       {{ define "repo/settings/fragments/secretListing" }}

     

       2
        
         {{ $root := index . 0 }}

     

       3
        
         {{ $secret := index . 1 }}

     

       4
       -
         <div

     

       5
       -
           id="secret-{{ $secret.Key }}"

     

       6
       -
           class="flex items-center justify-between p-2">

     

       7
       -
           <div

     

       8
       -
             class="hover:no-underline flex flex-col gap-1 text-sm min-w-0 max-w-[80%]">

     

       9
        
             <span class="font-mono">

     

       10
        
               {{ $secret.Key }}

     

       11
        
             </span>

     

       12
       -
             <div

     

       13
       -
               class="flex flex-wrap text items-center gap-1 text-gray-500 dark:text-gray-400">

     

       14
        
               <span>added by</span>

     

       15
       -
               <span>

     

       16
       -
                 {{ template "user/fragments/picHandleLink" $secret.CreatedBy }}

     

       17
       -
               </span>

     

       18
        
               <span class="before:content-['·'] before:select-none"></span>

     

       19
       -
               <span>

     

       20
       -
                 {{ template "repo/fragments/shortTimeAgo" $secret.CreatedAt }}

     

       21
       -
               </span>

     

       22
        
             </div>

     

       23
        
           </div>

     

       24
        
           <button

     
···

       27
        
             hx-delete="/{{ $root.RepoInfo.FullName }}/settings/secrets"

     

       28
        
             hx-swap="none"

     

       29
        
             hx-vals='{"key": "{{ $secret.Key }}"}'

     

       30
       -
             hx-confirm="Are you sure you want to delete the secret {{ $secret.Key }}?">

     

       0
        
       
     

       31
        
             {{ i "trash-2" "w-5 h-5" }}

     

       32
       -
             <span class="hidden md:inline">delete</span>

     

       33
        
             {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       34
        
           </button>

     

       35
        
         </div>

···

       1
        
       {{ define "repo/settings/fragments/secretListing" }}

     

       2
        
         {{ $root := index . 0 }}

     

       3
        
         {{ $secret := index . 1 }}

     

       4
       +
         <div id="secret-{{$secret.Key}}" class="flex items-center justify-between p-2">

     

       5
       +
           <div class="hover:no-underline flex flex-col gap-1 text-sm min-w-0 max-w-[80%]">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
             <span class="font-mono">

     

       7
        
               {{ $secret.Key }}

     

       8
        
             </span>

     

       9
       +
             <div class="flex flex-wrap text items-center gap-1 text-gray-500 dark:text-gray-400">

     

       0
        
       
     

       10
        
               <span>added by</span>

     

       11
       +
               <span>{{ template "user/fragments/picHandleLink" $secret.CreatedBy }}</span>

     

       0
        
       
     

       0
        
       
     

       12
        
               <span class="before:content-['·'] before:select-none"></span>

     

       13
       +
               <span>{{ template "repo/fragments/shortTimeAgo" $secret.CreatedAt }}</span>

     

       0
        
       
     

       0
        
       
     

       14
        
             </div>

     

       15
        
           </div>

     

       16
        
           <button

     
···

       19
        
             hx-delete="/{{ $root.RepoInfo.FullName }}/settings/secrets"

     

       20
        
             hx-swap="none"

     

       21
        
             hx-vals='{"key": "{{ $secret.Key }}"}'

     

       22
       +
             hx-confirm="Are you sure you want to delete the secret {{ $secret.Key }}?"

     

       23
       +
           >

     

       24
        
             {{ i "trash-2" "w-5 h-5" }}

     

       25
       +
             <span class="hidden md:inline">delete</span> 

     

       26
        
             {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       27
        
           </button>

     

       28
        
         </div>

+7 -15

appview/pages/templates/repo/settings/fragments/sidebar.html

···

       1
        
       {{ define "repo/settings/fragments/sidebar" }}

     

       2
        
         {{ $active := .Tab }}

     

       3
        
         {{ $tabs := .Tabs }}

     

       4
       -
         <div

     

       5
       -
           class="sticky top-2 grid grid-cols-1 rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 shadow-inner">

     

       6
        
           {{ $activeTab := "bg-white dark:bg-gray-700 drop-shadow-sm" }}

     

       7
        
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800" }}

     

       8
        
           {{ range $tabs }}

     

       9
       -
             <a

     

       10
       -
               href="/{{ $.RepoInfo.FullName }}/settings?tab={{ .Name }}"

     

       11
       -
               class="no-underline hover:no-underline hover:bg-gray-100/25 hover:dark:bg-gray-700/25">

     

       12
       -
               <div

     

       13
       -
                 class="flex gap-3 items-center p-2 {{ if eq .Name $active }}

     

       14
       -
                   {{ $activeTab }}

     

       15
       -
                 {{ else }}

     

       16
       -
                   {{ $inactiveTab }}

     

       17
       -
                 {{ end }}">

     

       18
       -
                 {{ i .Icon "size-4" }}

     

       19
       -
                 {{ .Name }}

     

       20
       -
               </div>

     

       21
       -
             </a>

     

       22
        
           {{ end }}

     

       23
        
         </div>

     

       24
        
       {{ end }}

···

       1
        
       {{ define "repo/settings/fragments/sidebar" }}

     

       2
        
         {{ $active := .Tab }}

     

       3
        
         {{ $tabs := .Tabs }}

     

       4
       +
         <div class="sticky top-2 grid grid-cols-1 rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 shadow-inner">

     

       0
        
       
     

       5
        
           {{ $activeTab := "bg-white dark:bg-gray-700 drop-shadow-sm" }}

     

       6
        
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800" }}

     

       7
        
           {{ range $tabs }}

     

       8
       +
           <a href="/{{ $.RepoInfo.FullName }}/settings?tab={{.Name}}" class="no-underline hover:no-underline hover:bg-gray-100/25 hover:dark:bg-gray-700/25">

     

       9
       +
             <div class="flex gap-3 items-center p-2 {{ if eq .Name $active }} {{ $activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       10
       +
               {{ i .Icon "size-4" }}

     

       11
       +
               {{ .Name }}

     

       12
       +
             </div>

     

       13
       +
           </a>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
           {{ end }}

     

       15
        
         </div>

     

       16
        
       {{ end }}

+84 -119

appview/pages/templates/timeline.html

···

       1
        
       {{ define "title" }}timeline{{ end }}

     

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
       -
         <meta property="og:title" content="timeline · tangled" />

     

       5
       -
         <meta property="og:type" content="object" />

     

       6
       -
         <meta property="og:url" content="https://tangled.sh" />

     

       7
       -
         <meta property="og:description" content="see what's tangling" />

     

       8
        
       {{ end }}

     

       9
        
       

     

       10
        
       {{ define "topbar" }}

     
···

       12
        
       {{ end }}

     

       13
        
       

     

       14
        
       {{ define "content" }}

     

       15
       -
         {{ with .LoggedInUser }}

     

       16
       -
           {{ block "timeline" $ }}{{ end }}

     

       17
       -
         {{ else }}

     

       18
       -
           {{ block "hero" $ }}{{ end }}

     

       19
       -
           {{ block "timeline" $ }}{{ end }}

     

       20
       -
         {{ end }}

     

       21
        
       {{ end }}

     

       22
        
       

     

       23
        
       {{ define "hero" }}

     

       24
       -
         <div class="flex flex-col text-black dark:text-white p-6 gap-6 max-w-xl">

     

       25
       -
           <div class="font-bold text-4xl">

     

       26
       -
             tightly-knit

     

       27
       -
             <br />

     

       28
       -
             social coding.

     

       29
       -
           </div>

     

       30
        
       

     

       31
       -
           <p class="text-lg">

     

       32
       -
             tangled is new social-enabled git collaboration platform built on

     

       33
       -
             <a class="underline" href="https://atproto.com/">atproto</a>

     

       34
       -
             .

     

       35
       -
           </p>

     

       36
       -
           <p class="text-lg">

     

       37
       -
             we envision a place where developers have complete ownership of their

     

       38
       -
             code, open source communities can freely self-govern and most importantly,

     

       39
       -
             coding can be social and fun again.

     

       40
       -
           </p>

     

       41
        
       

     

       42
       -
           <div class="flex gap-6 items-center">

     

       43
       -
             <a href="/signup" class="no-underline hover:no-underline ">

     

       44
       -
               <button class="btn-create flex gap-2 px-4 items-center">

     

       45
       -
                 join now

     

       46
       -
                 {{ i "arrow-right" "size-4" }}

     

       47
       -
               </button>

     

       48
       -
             </a>

     

       49
        
           </div>

     

       50
       -
         </div>

     

       51
        
       {{ end }}

     

       52
        
       

     

       53
        
       {{ define "timeline" }}

     

       54
       -
         <div>

     

       55
       -
           <div class="p-6">

     

       56
       -
             <p class="text-xl font-bold dark:text-white">Timeline</p>

     

       57
       -
           </div>

     

       58
        
       

     

       59
       -
           <div class="flex flex-col gap-4">

     

       60
       -
             {{ range $i, $e := .Timeline }}

     

       61
       -
               <div class="relative">

     

       62
       -
                 {{ if ne $i 0 }}

     

       63
       -
                   <div

     

       64
       -
                     class="absolute left-8 -top-4 w-px h-4 bg-gray-300 dark:bg-gray-600"></div>

     

       65
       -
                 {{ end }}

     

       66
       -
                 {{ with $e }}

     

       67
       -
                   <div

     

       68
       -
                     class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       69
       -
                     {{ if .Repo }}

     

       70
       -
                       {{ block "repoEvent" (list $ .Repo .Source) }}{{ end }}

     

       71
       -
                     {{ else if .Star }}

     

       72
       -
                       {{ block "starEvent" (list $ .Star) }}{{ end }}

     

       73
       -
                     {{ else if .Follow }}

     

       74
       -
                       {{ block "followEvent" (list $ .Follow .Profile .FollowStats) }}

     

       75
       -
                       {{ end }}

     

       76
        
                     {{ end }}

     

       77
        
                   </div>

     

       78
        
                 {{ end }}

     

       79
        
               </div>

     

       80
       -
             {{ end }}

     

       81
        
           </div>

     

       82
       -
         </div>

     

       83
        
       {{ end }}

     

       84
        
       

     

       85
        
       {{ define "repoEvent" }}

     
···

       87
        
         {{ $repo := index . 1 }}

     

       88
        
         {{ $source := index . 2 }}

     

       89
        
         {{ $userHandle := resolve $repo.Did }}

     

       90
       -
         <div

     

       91
       -
           class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       92
       -
           {{ template "user/fragments/picHandleLink" $repo.Did }}

     

       93
       -
           {{ with $source }}

     

       94
       -
             {{ $sourceDid := resolve .Did }}

     

       95
       -
             forked

     

       96
       -
             <a

     

       97
       -
               href="/{{ $sourceDid }}/{{ .Name }}"

     

       98
       -
               class="no-underline hover:underline">

     

       99
       -
               {{ $sourceDid }}/{{ .Name }}

     

       100
       -
             </a>

     

       101
       -
             to

     

       102
       -
             <a

     

       103
       -
               href="/{{ $userHandle }}/{{ $repo.Name }}"

     

       104
       -
               class="no-underline hover:underline">

     

       105
       -
               {{ $repo.Name }}

     

       106
       -
             </a>

     

       107
       -
           {{ else }}

     

       108
       -
             created

     

       109
       -
             <a

     

       110
       -
               href="/{{ $userHandle }}/{{ $repo.Name }}"

     

       111
       -
               class="no-underline hover:underline">

     

       112
       -
               {{ $repo.Name }}

     

       113
       -
             </a>

     

       114
       -
           {{ end }}

     

       115
       -
           <span class="text-gray-700 dark:text-gray-400 text-xs">

     

       116
       -
             {{ template "repo/fragments/time" $repo.Created }}

     

       117
       -
           </span>

     

       118
       -
         </div>

     

       119
        
         {{ with $repo }}

     

       120
        
           {{ template "user/fragments/repoCard" (list $root . true) }}

     

       121
        
         {{ end }}

     
···

       127
        
         {{ with $star }}

     

       128
        
           {{ $starrerHandle :=  resolve .StarredByDid }}

     

       129
        
           {{ $repoOwnerHandle :=  resolve .Repo.Did }}

     

       130
       -
           <div

     

       131
       -
             class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       132
       -
             {{ template "user/fragments/picHandleLink" $starrerHandle }}

     

       133
       -
             starred

     

       134
       -
             <a

     

       135
       -
               href="/{{ $repoOwnerHandle }}/{{ .Repo.Name }}"

     

       136
       -
               class="no-underline hover:underline">

     

       137
       -
               {{ $repoOwnerHandle | truncateAt30 }}/{{ .Repo.Name }}

     

       138
       -
             </a>

     

       139
       -
             <span class="text-gray-700 dark:text-gray-400 text-xs">

     

       140
       -
               {{ template "repo/fragments/time" .Created }}

     

       141
       -
             </span>

     

       142
        
           </div>

     

       143
        
           {{ with .Repo }}

     

       144
        
             {{ template "user/fragments/repoCard" (list $root . true) }}

     
···

       146
        
         {{ end }}

     

       147
        
       {{ end }}

     

       148
        
       

     

       0
        
       
     

       149
        
       {{ define "followEvent" }}

     

       150
        
         {{ $root := index . 0 }}

     

       151
        
         {{ $follow := index . 1 }}

     
···

       154
        
       

     

       155
        
         {{ $userHandle :=  resolve $follow.UserDid }}

     

       156
        
         {{ $subjectHandle :=  resolve $follow.SubjectDid }}

     

       157
       -
         <div

     

       158
       -
           class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       159
       -
           {{ template "user/fragments/picHandleLink" $userHandle }}

     

       160
       -
           followed

     

       161
       -
           {{ template "user/fragments/picHandleLink" $subjectHandle }}

     

       162
       -
           <span class="text-gray-700 dark:text-gray-400 text-xs">

     

       163
       -
             {{ template "repo/fragments/time" $follow.FollowedAt }}

     

       164
       -
           </span>

     

       165
        
         </div>

     

       166
       -
         <div

     

       167
       -
           class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4">

     

       168
        
           <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       169
       -
             <img

     

       170
       -
               class="object-cover rounded-full p-2"

     

       171
       -
               src="{{ fullAvatar $subjectHandle }}" />

     

       172
        
           </div>

     

       173
        
       

     

       174
        
           <div class="flex-1 min-h-0 justify-around flex flex-col">

     

       175
        
             <a href="/{{ $subjectHandle }}">

     

       176
       -
               <span

     

       177
       -
                 class="font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap max-w-full">

     

       178
       -
                 {{ $subjectHandle | truncateAt30 }}

     

       179
       -
               </span>

     

       180
        
             </a>

     

       181
        
             {{ with $profile }}

     

       182
        
               {{ with .Description }}

     

       183
       -
                 <p class="text-sm pb-2 md:pb-2">{{ . }}</p>

     

       184
        
               {{ end }}

     

       185
        
             {{ end }}

     

       186
        
             {{ with $stat }}

     

       187
       -
               <div

     

       188
       -
                 class="text-sm flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm">

     

       189
        
                 <span class="flex-shrink-0">{{ i "users" "size-4" }}</span>

     

       190
        
                 <span id="followers">{{ .Followers }} followers</span>

     

       191
        
                 <span class="select-none after:content-['·']"></span>

     

       192
       -
                 <span id="following">{{ .Following }} following</span>

     

       193
        
               </div>

     

       194
        
             {{ end }}

     

       195
        
           </div>

···

       1
        
       {{ define "title" }}timeline{{ end }}

     

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
       +
           <meta property="og:title" content="timeline · tangled" />

     

       5
       +
           <meta property="og:type" content="object" />

     

       6
       +
           <meta property="og:url" content="https://tangled.sh" />

     

       7
       +
           <meta property="og:description" content="see what's tangling" />

     

       8
        
       {{ end }}

     

       9
        
       

     

       10
        
       {{ define "topbar" }}

     
···

       12
        
       {{ end }}

     

       13
        
       

     

       14
        
       {{ define "content" }}

     

       15
       +
           {{ with .LoggedInUser }}

     

       16
       +
               {{ block "timeline" $ }}{{ end }}

     

       17
       +
           {{ else }}

     

       18
       +
               {{ block "hero" $ }}{{ end }}

     

       19
       +
               {{ block "timeline" $ }}{{ end }}

     

       20
       +
           {{ end }}

     

       21
        
       {{ end }}

     

       22
        
       

     

       23
        
       {{ define "hero" }}

     

       24
       +
           <div class="flex flex-col text-black dark:text-white p-6 gap-6 max-w-xl">

     

       25
       +
               <div class="font-bold text-4xl">tightly-knit<br>social coding.</div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
       +
               <p class="text-lg">

     

       28
       +
                 tangled is new social-enabled git collaboration platform built on <a class="underline" href="https://atproto.com/">atproto</a>.

     

       29
       +
               </p>

     

       30
       +
               <p class="text-lg">

     

       31
       +
                 we envision a place where developers have complete ownership of their

     

       32
       +
                 code, open source communities can freely self-govern and most

     

       33
       +
                 importantly, coding can be social and fun again.

     

       34
       +
               </p>

     

       0
        
       
     

       0
        
       
     

       35
        
       

     

       36
       +
               <div class="flex gap-6 items-center">

     

       37
       +
                 <a href="/signup" class="no-underline hover:no-underline ">

     

       38
       +
                   <button class="btn-create flex gap-2 px-4 items-center">

     

       39
       +
                     join now {{ i "arrow-right" "size-4" }}

     

       40
       +
                   </button>

     

       41
       +
                 </a>

     

       42
       +
               </div>

     

       43
        
           </div>

     

       0
        
       
     

       44
        
       {{ end }}

     

       45
        
       

     

       46
        
       {{ define "timeline" }}

     

       47
       +
           <div>

     

       48
       +
               <div class="p-6">

     

       49
       +
                   <p class="text-xl font-bold dark:text-white">Timeline</p>

     

       50
       +
               </div>

     

       51
        
       

     

       52
       +
               <div class="flex flex-col gap-4">

     

       53
       +
                 {{ range $i, $e := .Timeline }}

     

       54
       +
                   <div class="relative">

     

       55
       +
                     {{ if ne $i 0 }}

     

       56
       +
                       <div class="absolute left-8 -top-4 w-px h-4 bg-gray-300 dark:bg-gray-600"></div>

     

       57
       +
                     {{ end }}

     

       58
       +
                     {{ with $e }}

     

       59
       +
                       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       60
       +
                         {{ if .Repo }}

     

       61
       +
                           {{ block "repoEvent" (list $ .Repo .Source) }} {{ end }}

     

       62
       +
                         {{ else if .Star }}

     

       63
       +
                           {{ block "starEvent" (list $ .Star) }} {{ end }}

     

       64
       +
                         {{ else if .Follow }}

     

       65
       +
                           {{ block "followEvent" (list $ .Follow .Profile .FollowStats) }} {{ end }}

     

       66
       +
                         {{ end }}

     

       67
       +
                       </div>

     

       0
        
       
     

       68
        
                     {{ end }}

     

       69
        
                   </div>

     

       70
        
                 {{ end }}

     

       71
        
               </div>

     

       0
        
       
     

       72
        
           </div>

     

       0
        
       
     

       73
        
       {{ end }}

     

       74
        
       

     

       75
        
       {{ define "repoEvent" }}

     
···

       77
        
         {{ $repo := index . 1 }}

     

       78
        
         {{ $source := index . 2 }}

     

       79
        
         {{ $userHandle := resolve $repo.Did }}

     

       80
       +
           <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       81
       +
             {{ template "user/fragments/picHandleLink" $repo.Did }}

     

       82
       +
             {{ with $source }}

     

       83
       +
               {{ $sourceDid := resolve .Did }}

     

       84
       +
               forked

     

       85
       +
               <a href="/{{ $sourceDid }}/{{ .Name }}"class="no-underline hover:underline">

     

       86
       +
                   {{ $sourceDid }}/{{ .Name }}

     

       87
       +
               </a>

     

       88
       +
               to

     

       89
       +
               <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline">{{ $repo.Name }}</a>

     

       90
       +
             {{ else }}

     

       91
       +
               created

     

       92
       +
               <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline">

     

       93
       +
                 {{ $repo.Name }}

     

       94
       +
               </a>

     

       95
       +
             {{ end }}

     

       96
       +
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $repo.Created }}</span>

     

       97
       +
           </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       98
        
         {{ with $repo }}

     

       99
        
           {{ template "user/fragments/repoCard" (list $root . true) }}

     

       100
        
         {{ end }}

     
···

       106
        
         {{ with $star }}

     

       107
        
           {{ $starrerHandle :=  resolve .StarredByDid }}

     

       108
        
           {{ $repoOwnerHandle :=  resolve .Repo.Did }}

     

       109
       +
           <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       110
       +
               {{ template "user/fragments/picHandleLink" $starrerHandle }}

     

       111
       +
               starred

     

       112
       +
               <a href="/{{ $repoOwnerHandle }}/{{ .Repo.Name }}" class="no-underline hover:underline">

     

       113
       +
                 {{ $repoOwnerHandle | truncateAt30 }}/{{ .Repo.Name }}

     

       114
       +
               </a>

     

       115
       +
               <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" .Created }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       116
        
           </div>

     

       117
        
           {{ with .Repo }}

     

       118
        
             {{ template "user/fragments/repoCard" (list $root . true) }}

     
···

       120
        
         {{ end }}

     

       121
        
       {{ end }}

     

       122
        
       

     

       123
       +
       

     

       124
        
       {{ define "followEvent" }}

     

       125
        
         {{ $root := index . 0 }}

     

       126
        
         {{ $follow := index . 1 }}

     
···

       129
        
       

     

       130
        
         {{ $userHandle :=  resolve $follow.UserDid }}

     

       131
        
         {{ $subjectHandle :=  resolve $follow.SubjectDid }}

     

       132
       +
         <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">

     

       133
       +
             {{ template "user/fragments/picHandleLink" $userHandle }}

     

       134
       +
             followed

     

       135
       +
             {{ template "user/fragments/picHandleLink" $subjectHandle }}

     

       136
       +
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $follow.FollowedAt }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       137
        
         </div>

     

       138
       +
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4">

     

       0
        
       
     

       139
        
           <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       140
       +
             <img class="object-cover rounded-full p-2" src="{{ fullAvatar $subjectHandle }}" />

     

       0
        
       
     

       0
        
       
     

       141
        
           </div>

     

       142
        
       

     

       143
        
           <div class="flex-1 min-h-0 justify-around flex flex-col">

     

       144
        
             <a href="/{{ $subjectHandle }}">

     

       145
       +
               <span class="font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap max-w-full">{{ $subjectHandle | truncateAt30 }}</span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       146
        
             </a>

     

       147
        
             {{ with $profile }}

     

       148
        
               {{ with .Description }}

     

       149
       +
                 <p class="text-sm pb-2 md:pb-2">{{.}}</p>

     

       150
        
               {{ end }}

     

       151
        
             {{ end }}

     

       152
        
             {{ with $stat }}

     

       153
       +
               <div class="text-sm flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm">

     

       0
        
       
     

       154
        
                 <span class="flex-shrink-0">{{ i "users" "size-4" }}</span>

     

       155
        
                 <span id="followers">{{ .Followers }} followers</span>

     

       156
        
                 <span class="select-none after:content-['·']"></span>

     

       157
       +
                 <span id="following">{{  .Following  }} following</span>

     

       158
        
               </div>

     

       159
        
             {{ end }}

     

       160
        
           </div>

+29 -48

appview/pages/templates/user/fragments/editPins.html

···

       1
        
       {{ define "user/fragments/editPins" }}

     

       2
        
         {{ $profile := .Profile }}

     

       3
       -
         <form

     

       4
       -
           hx-post="/profile/pins"

     

       5
       -
           hx-disabled-elt="#save-btn,#cancel-btn"

     

       6
       -
           hx-swap="none"

     

       7
       -
           hx-indicator="#spinner">

     

       8
       -
           <div class="flex items-center justify-between mb-2">

     

       9
       -
             <p class="text-sm font-bold p-2 dark:text-white">SELECT PINNED REPOS</p>

     

       10
       -
             <div class="flex items-center gap-2">

     

       11
       -
               <button

     

       12
       -
                 id="save-btn"

     

       13
       -
                 type="submit"

     

       14
       -
                 class="btn px-2 flex items-center gap-2 no-underline text-sm">

     

       15
       -
                 {{ i "check" "w-3 h-3" }} save

     

       16
       -
                 <span id="spinner" class="group">

     

       17
       -
                   {{ i "loader-circle" "w-3 h-3 animate-spin hidden group-[.htmx-request]:inline" }}

     

       18
       -
                 </span>

     

       19
       -
               </button>

     

       20
       -
               <a

     

       21
       -
                 href="/{{ .LoggedInUser.Did }}"

     

       22
       -
                 class="w-full no-underline hover:no-underline">

     

       23
       -
                 <button

     

       24
       -
                   id="cancel-btn"

     

       25
       -
                   type="button"

     

       26
       -
                   class="btn px-2 w-full flex items-center gap-2 no-underline text-sm">

     

       27
       -
                   {{ i "x" "w-3 h-3" }} cancel

     

       28
        
                 </button>

     

       29
       -
               </a>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
             </div>

     

       31
       -
           </div>

     

       32
       -
           <div

     

       33
       -
             id="repos"

     

       34
       -
             class="grid grid-cols-1 gap-1 mb-6 bg-white dark:bg-gray-800  border border-gray-200 dark:border-gray-700">

     

       35
       -
             {{ range $idx, $r := .AllRepos }}

     

       36
       -
               <div

     

       37
       -
                 class="flex items-center gap-2 text-base p-2 border-b border-gray-200 dark:border-gray-700">

     

       38
       -
                 <input

     

       39
       -
                   type="checkbox"

     

       40
       -
                   id="repo-{{ $idx }}"

     

       41
       -
                   name="pinnedRepo{{ $idx }}"

     

       42
       -
                   value="{{ .RepoAt }}"

     

       43
       -
                   {{ if .IsPinned }}checked{{ end }} />

     

       44
       -
                 <label

     

       45
       -
                   for="repo-{{ $idx }}"

     

       46
       -
                   class="my-0 py-0 normal-case font-normal w-full">

     

       47
        
                   <div class="flex justify-between items-center w-full">

     

       48
       -
                     <span class="flex-shrink-0 overflow-hidden text-ellipsis ">

     

       49
       -
                       {{ resolve .Did }}/{{ .Name }}

     

       50
       -
                     </span>

     

       51
        
                     <div class="flex gap-1 items-center">

     

       52
        
                       {{ i "star" "size-4 fill-current" }}

     

       53
        
                       <span>{{ .RepoStats.StarCount }}</span>

     
···

       55
        
                   </div>

     

       56
        
                 </label>

     

       57
        
               </div>

     

       58
       -
             {{ end }}

     

       59
       -
           </div>

     

       60
       -
         </form>

     

       0
        
       
     

       61
        
       {{ end }}

···

       1
        
       {{ define "user/fragments/editPins" }}

     

       2
        
         {{ $profile := .Profile }}

     

       3
       +
           <form

     

       4
       +
               hx-post="/profile/pins"

     

       5
       +
               hx-disabled-elt="#save-btn,#cancel-btn"

     

       6
       +
               hx-swap="none"

     

       7
       +
               hx-indicator="#spinner">

     

       8
       +
             <div class="flex items-center justify-between mb-2">

     

       9
       +
               <p class="text-sm font-bold p-2 dark:text-white">SELECT PINNED REPOS</p>

     

       10
       +
               <div class="flex items-center gap-2">

     

       11
       +
                 <button id="save-btn" type="submit" class="btn px-2 flex items-center gap-2 no-underline text-sm">

     

       12
       +
                   {{ i "check" "w-3 h-3" }} save 

     

       13
       +
                   <span id="spinner" class="group">

     

       14
       +
                     {{ i "loader-circle" "w-3 h-3 animate-spin hidden group-[.htmx-request]:inline" }}

     

       15
       +
                   </span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
                 </button>

     

       17
       +
                 <a href="/{{.LoggedInUser.Did}}" class="w-full no-underline hover:no-underline">

     

       18
       +
                   <button id="cancel-btn" type="button" class="btn px-2 w-full flex items-center gap-2 no-underline text-sm">

     

       19
       +
                     {{ i "x" "w-3 h-3" }} cancel

     

       20
       +
                   </button>

     

       21
       +
                 </a>

     

       22
       +
               </div>

     

       23
        
             </div>

     

       24
       +
             <div id="repos" class="grid grid-cols-1 gap-1 mb-6 bg-white dark:bg-gray-800  border border-gray-200 dark:border-gray-700">

     

       25
       +
               {{ range $idx, $r := .AllRepos }}

     

       26
       +
               <div class="flex items-center gap-2 text-base p-2 border-b border-gray-200 dark:border-gray-700">

     

       27
       +
                 <input type="checkbox" id="repo-{{$idx}}" name="pinnedRepo{{$idx}}" value="{{.RepoAt}}" {{if .IsPinned}}checked{{end}}>

     

       28
       +
                 <label for="repo-{{$idx}}" class="my-0 py-0 normal-case font-normal w-full">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       29
        
                   <div class="flex justify-between items-center w-full">

     

       30
       +
                     <span class="flex-shrink-0 overflow-hidden text-ellipsis ">{{ resolve .Did }}/{{.Name}}</span>

     

       0
        
       
     

       0
        
       
     

       31
        
                     <div class="flex gap-1 items-center">

     

       32
        
                       {{ i "star" "size-4 fill-current" }}

     

       33
        
                       <span>{{ .RepoStats.StarCount }}</span>

     
···

       35
        
                   </div>

     

       36
        
                 </label>

     

       37
        
               </div>

     

       38
       +
               {{ end }}

     

       39
       +
             </div>

     

       40
       +
       

     

       41
       +
           </form>

     

       42
        
       {{ end }}

-55

appview/pages/templates/repo/fragments/cloneInstructions.html

···

       1
       -
       {{ define "repo/fragments/cloneInstructions" }}

     

       2
       -
           {{ $knot := .RepoInfo.Knot }}

     

       3
       -
           {{ if eq $knot "knot1.tangled.sh" }}

     

       4
       -
               {{ $knot = "tangled.sh" }}

     

       5
       -
           {{ end }}

     

       6
       -
           <section

     

       7
       -
               class="mt-4 p-6 rounded drop-shadow-sm bg-white dark:bg-gray-800 dark:text-white w-full mx-auto overflow-auto flex flex-col gap-4"

     

       8
       -
           >

     

       9
       -
               <div class="flex flex-col gap-2">

     

       10
       -
                   <strong>push</strong>

     

       11
       -
                   <div class="md:pl-4 overflow-x-auto whitespace-nowrap">

     

       12
       -
                       <code class="dark:text-gray-100"

     

       13
       -
                           >git remote add origin

     

       14
       -
                           git@{{ $knot }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code

     

       15
       -
                       >

     

       16
       -
                   </div>

     

       17
       -
               </div>

     

       18
       -
       

     

       19
       -
               <div class="flex flex-col gap-2">

     

       20
       -
                   <strong>clone</strong>

     

       21
       -
                   <div class="md:pl-4 flex flex-col gap-2">

     

       22
       -
                       <div class="flex items-center gap-3">

     

       23
       -
                           <span

     

       24
       -
                               class="bg-gray-100 dark:bg-gray-700 p-1 mr-1 font-mono text-sm rounded select-none dark:text-white"

     

       25
       -
                               >HTTP</span

     

       26
       -
                           >

     

       27
       -
                           <div class="overflow-x-auto whitespace-nowrap flex-1">

     

       28
       -
                               <code class="dark:text-gray-100"

     

       29
       -
                                   >git clone

     

       30
       -
                                   https://tangled.sh/{{ .RepoInfo.OwnerWithAt }}/{{ .RepoInfo.Name }}</code

     

       31
       -
                               >

     

       32
       -
                           </div>

     

       33
       -
                       </div>

     

       34
       -
       

     

       35
       -
                       <div class="flex items-center gap-3">

     

       36
       -
                           <span

     

       37
       -
                               class="bg-gray-100 dark:bg-gray-700 p-1 mr-1 font-mono text-sm rounded select-none dark:text-white"

     

       38
       -
                               >SSH</span

     

       39
       -
                           >

     

       40
       -
                           <div class="overflow-x-auto whitespace-nowrap flex-1">

     

       41
       -
                               <code class="dark:text-gray-100"

     

       42
       -
                                   >git clone

     

       43
       -
                                   git@{{ $knot }}:{{ .RepoInfo.OwnerHandle }}/{{ .RepoInfo.Name }}</code

     

       44
       -
                               >

     

       45
       -
                           </div>

     

       46
       -
                       </div>

     

       47
       -
                   </div>

     

       48
       -
               </div>

     

       49
       -
       

     

       50
       -
               <p class="py-2 text-gray-500 dark:text-gray-400">

     

       51
       -
                   Note that for self-hosted knots, clone URLs may be different based

     

       52
       -
                   on your setup.

     

       53
       -
               </p>

     

       54
       -
           </section>

     

       55
       -
       {{ end }}

-4

appview/pages/templates/repo/empty.html

···

       44
        
           {{ end }}

     

       45
        
         </main>

     

       46
        
       {{ end }}

     

       47
       -
       

     

       48
       -
       {{ define "repoAfter" }}

     

       49
       -
           {{ template "repo/fragments/cloneInstructions" . }}

     

       50
       -
       {{ end }}

+1 -1

spindle/engine/ansi_stripper.go spindle/engines/nixery/ansi_stripper.go

···

       1
       -
       package engine

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"io"

···

       1
       +
       package nixery

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"io"

+1 -1

spindle/engine/envs.go spindle/engines/nixery/envs.go

···

       1
       -
       package engine

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"fmt"

···

       1
       +
       package nixery

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"fmt"

+1 -1

spindle/engine/envs_test.go spindle/engines/nixery/envs_test.go

···

       1
       -
       package engine

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"testing"

···

       1
       +
       package nixery

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"testing"

spindle/engines/nixery/errors.go

···

       1
       +
       package nixery

     

       2
       +
       

     

       3
       +
       import "errors"

     

       4
       +
       

     

       5
       +
       var (

     

       6
       +
       	ErrOOMKilled = errors.New("oom killed")

     

       7
       +
       )

+8 -10

spindle/engine/logger.go spindle/models/logger.go

···

       1
       -
       package engine

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"encoding/json"

     
···

       7
        
       	"os"

     

       8
        
       	"path/filepath"

     

       9
        
       	"strings"

     

       10
       -
       

     

       11
       -
       	"tangled.sh/tangled.sh/core/spindle/models"

     

       12
        
       )

     

       13
        
       

     

       14
        
       type WorkflowLogger struct {

     
···

       16
        
       	encoder *json.Encoder

     

       17
        
       }

     

       18
        
       

     

       19
       -
       func NewWorkflowLogger(baseDir string, wid models.WorkflowId) (*WorkflowLogger, error) {

     

       20
        
       	path := LogFilePath(baseDir, wid)

     

       21
        
       

     

       22
        
       	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)

     
···

       30
        
       	}, nil

     

       31
        
       }

     

       32
        
       

     

       33
       -
       func LogFilePath(baseDir string, workflowID models.WorkflowId) string {

     

       34
        
       	logFilePath := filepath.Join(baseDir, fmt.Sprintf("%s.log", workflowID.String()))

     

       35
        
       	return logFilePath

     

       36
        
       }

     
···

       47
        
       	}

     

       48
        
       }

     

       49
        
       

     

       50
       -
       func (l *WorkflowLogger) ControlWriter(idx int, step models.Step) io.Writer {

     

       51
        
       	return &controlWriter{

     

       52
        
       		logger: l,

     

       53
        
       		idx:    idx,

     
···

       62
        
       

     

       63
        
       func (w *dataWriter) Write(p []byte) (int, error) {

     

       64
        
       	line := strings.TrimRight(string(p), "\r\n")

     

       65
       -
       	entry := models.NewDataLogLine(line, w.stream)

     

       66
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       67
        
       		return 0, err

     

       68
        
       	}

     
···

       72
        
       type controlWriter struct {

     

       73
        
       	logger *WorkflowLogger

     

       74
        
       	idx    int

     

       75
       -
       	step   models.Step

     

       76
        
       }

     

       77
        
       

     

       78
        
       func (w *controlWriter) Write(_ []byte) (int, error) {

     

       79
       -
       	entry := models.NewControlLogLine(w.idx, w.step)

     

       80
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       81
        
       		return 0, err

     

       82
        
       	}

     

       83
       -
       	return len(w.step.Name), nil

     

       84
        
       }

···

       1
       +
       package models

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"encoding/json"

     
···

       7
        
       	"os"

     

       8
        
       	"path/filepath"

     

       9
        
       	"strings"

     

       0
        
       
     

       0
        
       
     

       10
        
       )

     

       11
        
       

     

       12
        
       type WorkflowLogger struct {

     
···

       14
        
       	encoder *json.Encoder

     

       15
        
       }

     

       16
        
       

     

       17
       +
       func NewWorkflowLogger(baseDir string, wid WorkflowId) (*WorkflowLogger, error) {

     

       18
        
       	path := LogFilePath(baseDir, wid)

     

       19
        
       

     

       20
        
       	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)

     
···

       28
        
       	}, nil

     

       29
        
       }

     

       30
        
       

     

       31
       +
       func LogFilePath(baseDir string, workflowID WorkflowId) string {

     

       32
        
       	logFilePath := filepath.Join(baseDir, fmt.Sprintf("%s.log", workflowID.String()))

     

       33
        
       	return logFilePath

     

       34
        
       }

     
···

       45
        
       	}

     

       46
        
       }

     

       47
        
       

     

       48
       +
       func (l *WorkflowLogger) ControlWriter(idx int, step Step) io.Writer {

     

       49
        
       	return &controlWriter{

     

       50
        
       		logger: l,

     

       51
        
       		idx:    idx,

     
···

       60
        
       

     

       61
        
       func (w *dataWriter) Write(p []byte) (int, error) {

     

       62
        
       	line := strings.TrimRight(string(p), "\r\n")

     

       63
       +
       	entry := NewDataLogLine(line, w.stream)

     

       64
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       65
        
       		return 0, err

     

       66
        
       	}

     
···

       70
        
       type controlWriter struct {

     

       71
        
       	logger *WorkflowLogger

     

       72
        
       	idx    int

     

       73
       +
       	step   Step

     

       74
        
       }

     

       75
        
       

     

       76
        
       func (w *controlWriter) Write(_ []byte) (int, error) {

     

       77
       +
       	entry := NewControlLogLine(w.idx, w.step)

     

       78
        
       	if err := w.logger.encoder.Encode(entry); err != nil {

     

       79
        
       		return 0, err

     

       80
        
       	}

     

       81
       +
       	return len(w.step.Name()), nil

     

       82
        
       }

+8 -103

spindle/models/pipeline.go

···

       1
        
       package models

     

       2
        
       

     

       3
       -
       import (

     

       4
       -
       	"path"

     

       5
       -
       

     

       6
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       7
       -
       	"tangled.sh/tangled.sh/core/spindle/config"

     

       8
       -
       )

     

       9
       -
       

     

       10
        
       type Pipeline struct {

     

       11
        
       	RepoOwner string

     

       12
        
       	RepoName  string

     

       13
       -
       	Workflows []Workflow

     

       14
        
       }

     

       15
        
       

     

       16
       -
       type Step struct {

     

       17
       -
       	Command     string

     

       18
       -
       	Name        string

     

       19
       -
       	Environment map[string]string

     

       20
       -
       	Kind        StepKind

     

       21
        
       }

     

       22
        
       

     

       23
        
       type StepKind int

     
···

       30
        
       )

     

       31
        
       

     

       32
        
       type Workflow struct {

     

       33
       -
       	Steps       []Step

     

       34
       -
       	Environment map[string]string

     

       35
       -
       	Name        string

     

       36
       -
       	Image       string

     

       37
       -
       }

     

       38
       -
       

     

       39
       -
       // setupSteps get added to start of Steps

     

       40
       -
       type setupSteps []Step

     

       41
       -
       

     

       42
       -
       // addStep adds a step to the beginning of the workflow's steps.

     

       43
       -
       func (ss *setupSteps) addStep(step Step) {

     

       44
       -
       	*ss = append(*ss, step)

     

       45
       -
       }

     

       46
       -
       

     

       47
       -
       // ToPipeline converts a tangled.Pipeline into a model.Pipeline.

     

       48
       -
       // In the process, dependencies are resolved: nixpkgs deps

     

       49
       -
       // are constructed atop nixery and set as the Workflow.Image,

     

       50
       -
       // and ones from custom registries

     

       51
       -
       func ToPipeline(pl tangled.Pipeline, cfg config.Config) *Pipeline {

     

       52
       -
       	workflows := []Workflow{}

     

       53
       -
       

     

       54
       -
       	for _, twf := range pl.Workflows {

     

       55
       -
       		swf := &Workflow{}

     

       56
       -
       		for _, tstep := range twf.Steps {

     

       57
       -
       			sstep := Step{}

     

       58
       -
       			sstep.Environment = stepEnvToMap(tstep.Environment)

     

       59
       -
       			sstep.Command = tstep.Command

     

       60
       -
       			sstep.Name = tstep.Name

     

       61
       -
       			sstep.Kind = StepKindUser

     

       62
       -
       			swf.Steps = append(swf.Steps, sstep)

     

       63
       -
       		}

     

       64
       -
       		swf.Name = twf.Name

     

       65
       -
       		swf.Environment = workflowEnvToMap(twf.Environment)

     

       66
       -
       		swf.Image = workflowImage(twf.Dependencies, cfg.Pipelines.Nixery)

     

       67
       -
       

     

       68
       -
       		setup := &setupSteps{}

     

       69
       -
       

     

       70
       -
       		setup.addStep(nixConfStep())

     

       71
       -
       		setup.addStep(cloneStep(*twf, *pl.TriggerMetadata, cfg.Server.Dev))

     

       72
       -
       		// this step could be empty

     

       73
       -
       		if s := dependencyStep(*twf); s != nil {

     

       74
       -
       			setup.addStep(*s)

     

       75
       -
       		}

     

       76
       -
       

     

       77
       -
       		// append setup steps in order to the start of workflow steps

     

       78
       -
       		swf.Steps = append(*setup, swf.Steps...)

     

       79
       -
       

     

       80
       -
       		workflows = append(workflows, *swf)

     

       81
       -
       	}

     

       82
       -
       	repoOwner := pl.TriggerMetadata.Repo.Did

     

       83
       -
       	repoName := pl.TriggerMetadata.Repo.Repo

     

       84
       -
       	return &Pipeline{

     

       85
       -
       		RepoOwner: repoOwner,

     

       86
       -
       		RepoName:  repoName,

     

       87
       -
       		Workflows: workflows,

     

       88
       -
       	}

     

       89
       -
       }

     

       90
       -
       

     

       91
       -
       func workflowEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string {

     

       92
       -
       	envMap := map[string]string{}

     

       93
       -
       	for _, env := range envs {

     

       94
       -
       		if env != nil {

     

       95
       -
       			envMap[env.Key] = env.Value

     

       96
       -
       		}

     

       97
       -
       	}

     

       98
       -
       	return envMap

     

       99
       -
       }

     

       100
       -
       

     

       101
       -
       func stepEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string {

     

       102
       -
       	envMap := map[string]string{}

     

       103
       -
       	for _, env := range envs {

     

       104
       -
       		if env != nil {

     

       105
       -
       			envMap[env.Key] = env.Value

     

       106
       -
       		}

     

       107
       -
       	}

     

       108
       -
       	return envMap

     

       109
       -
       }

     

       110
       -
       

     

       111
       -
       func workflowImage(deps []*tangled.Pipeline_Dependency, nixery string) string {

     

       112
       -
       	var dependencies string

     

       113
       -
       	for _, d := range deps {

     

       114
       -
       		if d.Registry == "nixpkgs" {

     

       115
       -
       			dependencies = path.Join(d.Packages...)

     

       116
       -
       		}

     

       117
       -
       	}

     

       118
       -
       

     

       119
       -
       	// load defaults from somewhere else

     

       120
       -
       	dependencies = path.Join(dependencies, "bash", "git", "coreutils", "nix")

     

       121
       -
       

     

       122
       -
       	return path.Join(nixery, dependencies)

     

       123
        
       }

···

       1
        
       package models

     

       2
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
       type Pipeline struct {

     

       4
        
       	RepoOwner string

     

       5
        
       	RepoName  string

     

       6
       +
       	Workflows map[Engine][]Workflow

     

       7
        
       }

     

       8
        
       

     

       9
       +
       type Step interface {

     

       10
       +
       	Name() string

     

       11
       +
       	Command() string

     

       12
       +
       	Kind() StepKind

     

       0
        
       
     

       13
        
       }

     

       14
        
       

     

       15
        
       type StepKind int

     
···

       22
        
       )

     

       23
        
       

     

       24
        
       type Workflow struct {

     

       25
       +
       	Steps []Step

     

       26
       +
       	Name  string

     

       27
       +
       	Data  any

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       28
        
       }

+1 -86

workflow/def_test.go

···

       10
        
       	yamlData := `

     

       11
        
       when:

     

       12
        
         - event: ["push", "pull_request"]

     

       13
       -
           branch: ["main", "develop"]

     

       14
       -
       

     

       15
       -
       dependencies:

     

       16
       -
         nixpkgs:

     

       17
       -
           - go

     

       18
       -
           - git

     

       19
       -
           - curl

     

       20
       -
       

     

       21
       -
       steps:

     

       22
       -
         - name: "Test"

     

       23
       -
           command: |

     

       24
       -
              go test ./...`

     

       25
        
       

     

       26
        
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       27
        
       	assert.NoError(t, err, "YAML should unmarshal without error")

     
···

       30
        
       	assert.ElementsMatch(t, []string{"main", "develop"}, wf.When[0].Branch)

     

       31
        
       	assert.ElementsMatch(t, []string{"push", "pull_request"}, wf.When[0].Event)

     

       32
        
       

     

       33
       -
       	assert.Len(t, wf.Steps, 1)

     

       34
       -
       	assert.Equal(t, "Test", wf.Steps[0].Name)

     

       35
       -
       	assert.Equal(t, "go test ./...", wf.Steps[0].Command)

     

       36
       -
       

     

       37
       -
       	pkgs, ok := wf.Dependencies["nixpkgs"]

     

       38
       -
       	assert.True(t, ok, "`nixpkgs` should be present in dependencies")

     

       39
       -
       	assert.ElementsMatch(t, []string{"go", "git", "curl"}, pkgs)

     

       40
       -
       

     

       41
        
       	assert.False(t, wf.CloneOpts.Skip, "Skip should default to false")

     

       42
        
       }

     

       43
        
       

     

       44
       -
       func TestUnmarshalCustomRegistry(t *testing.T) {

     

       45
       -
       	yamlData := `

     

       46
       -
       when:

     

       47
       -
         - event: push

     

       48
       -
           branch: main

     

       49
       -
       

     

       50
       -
       dependencies:

     

       51
       -
         git+https://tangled.sh/@oppi.li/tbsp:

     

       52
       -
           - tbsp

     

       53
       -
         git+https://git.peppe.rs/languages/statix:

     

       54
       -
           - statix

     

       55
       -
       

     

       56
       -
       steps:

     

       57
       -
         - name: "Check"

     

       58
       -
           command: |

     

       59
       -
              statix check`

     

       60
       -
       

     

       61
       -
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       62
       -
       	assert.NoError(t, err, "YAML should unmarshal without error")

     

       63
       -
       

     

       64
       -
       	assert.ElementsMatch(t, []string{"push"}, wf.When[0].Event)

     

       65
       -
       	assert.ElementsMatch(t, []string{"main"}, wf.When[0].Branch)

     

       66
       -
       

     

       67
       -
       	assert.ElementsMatch(t, []string{"tbsp"}, wf.Dependencies["git+https://tangled.sh/@oppi.li/tbsp"])

     

       68
       -
       	assert.ElementsMatch(t, []string{"statix"}, wf.Dependencies["git+https://git.peppe.rs/languages/statix"])

     

       69
       -
       }

     

       70
       -
       

     

       71
        
       func TestUnmarshalCloneFalse(t *testing.T) {

     

       72
        
       	yamlData := `

     

       73
        
       when:

     
···

       75
        
       

     

       76
        
       clone:

     

       77
        
         skip: true

     

       78
       -
       

     

       79
       -
       dependencies:

     

       80
       -
         nixpkgs:

     

       81
       -
           - python3

     

       82
       -
       

     

       83
       -
       steps:

     

       84
       -
         - name: Notify

     

       85
       -
           command: |

     

       86
       -
             python3 ./notify.py

     

       87
        
       `

     

       88
        
       

     

       89
        
       	wf, err := FromFile("test.yml", []byte(yamlData))

     
···

       93
        
       

     

       94
        
       	assert.True(t, wf.CloneOpts.Skip, "Skip should be false")

     

       95
        
       }

     

       96
       -
       

     

       97
       -
       func TestUnmarshalEnv(t *testing.T) {

     

       98
       -
       	yamlData := `

     

       99
       -
       when:

     

       100
       -
         - event: ["pull_request_close"]

     

       101
       -
       

     

       102
       -
       clone:

     

       103
       -
         skip: false

     

       104
       -
       

     

       105
       -
       environment:

     

       106
       -
         HOME: /home/foo bar/baz

     

       107
       -
         CGO_ENABLED: 1

     

       108
       -
       

     

       109
       -
       steps:

     

       110
       -
         - name: Something

     

       111
       -
           command: echo "hello"

     

       112
       -
           environment:

     

       113
       -
             FOO: bar

     

       114
       -
             BAZ: qux

     

       115
       -
       `

     

       116
       -
       

     

       117
       -
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       118
       -
       	assert.NoError(t, err)

     

       119
       -
       

     

       120
       -
       	assert.Len(t, wf.Environment, 2)

     

       121
       -
       	assert.Equal(t, "/home/foo bar/baz", wf.Environment["HOME"])

     

       122
       -
       	assert.Equal(t, "1", wf.Environment["CGO_ENABLED"])

     

       123
       -
       	assert.Equal(t, "bar", wf.Steps[0].Environment["FOO"])

     

       124
       -
       	assert.Equal(t, "qux", wf.Steps[0].Environment["BAZ"])

     

       125
       -
       }

···

       10
        
       	yamlData := `

     

       11
        
       when:

     

       12
        
         - event: ["push", "pull_request"]

     

       13
       +
           branch: ["main", "develop"]`

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
        
       	wf, err := FromFile("test.yml", []byte(yamlData))

     

       16
        
       	assert.NoError(t, err, "YAML should unmarshal without error")

     
···

       19
        
       	assert.ElementsMatch(t, []string{"main", "develop"}, wf.When[0].Branch)

     

       20
        
       	assert.ElementsMatch(t, []string{"push", "pull_request"}, wf.When[0].Event)

     

       21
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
       	assert.False(t, wf.CloneOpts.Skip, "Skip should default to false")

     

       23
        
       }

     

       24
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
       func TestUnmarshalCloneFalse(t *testing.T) {

     

       26
        
       	yamlData := `

     

       27
        
       when:

     
···

       29
        
       

     

       30
        
       clone:

     

       31
        
         skip: true

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       `

     

       33
        
       

     

       34
        
       	wf, err := FromFile("test.yml", []byte(yamlData))

     
···

       38
        
       

     

       39
        
       	assert.True(t, wf.CloneOpts.Skip, "Skip should be false")

     

       40
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

+1 -1

appview/pages/templates/repo/fragments/repoDescription.html

···

       1
        
       {{ define "repo/fragments/repoDescription" }}

     

       2
        
       <span id="repo-description" class="flex flex-wrap items-center gap-2 text-sm" hx-target="this" hx-swap="outerHTML">

     

       3
        
           {{ if .RepoInfo.Description }}

     

       4
       -
               {{ .RepoInfo.Description }}

     

       5
        
           {{ else }}

     

       6
        
               <span class="italic">this repo has no description</span>

     

       7
        
           {{ end }}

···

       1
        
       {{ define "repo/fragments/repoDescription" }}

     

       2
        
       <span id="repo-description" class="flex flex-wrap items-center gap-2 text-sm" hx-target="this" hx-swap="outerHTML">

     

       3
        
           {{ if .RepoInfo.Description }}

     

       4
       +
               {{ .RepoInfo.Description | description }}

     

       5
        
           {{ else }}

     

       6
        
               <span class="italic">this repo has no description</span>

     

       7
        
           {{ end }}

+4 -8

knotserver/git/fork.go

···

       10
        
       )

     

       11
        
       

     

       12
        
       func Fork(repoPath, source string) error {

     

       13
       -
       	_, err := git.PlainClone(repoPath, true, &git.CloneOptions{

     

       14
       -
       		URL:          source,

     

       15
       -
       		SingleBranch: false,

     

       16
       -
       	})

     

       17
       -
       

     

       18
       -
       	if err != nil {

     

       19
        
       		return fmt.Errorf("failed to bare clone repository: %w", err)

     

       20
        
       	}

     

       21
        
       

     

       22
       -
       	err = exec.Command("git", "-C", repoPath, "config", "receive.hideRefs", "refs/hidden").Run()

     

       23
       -
       	if err != nil {

     

       24
        
       		return fmt.Errorf("failed to configure hidden refs: %w", err)

     

       25
        
       	}

     

       26

···

       10
        
       )

     

       11
        
       

     

       12
        
       func Fork(repoPath, source string) error {

     

       13
       +
       	cloneCmd := exec.Command("git", "clone", "--bare", source, repoPath)

     

       14
       +
       	if err := cloneCmd.Run(); err != nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
       		return fmt.Errorf("failed to bare clone repository: %w", err)

     

       16
        
       	}

     

       17
        
       

     

       18
       +
       	configureCmd := exec.Command("git", "-C", repoPath, "config", "receive.hideRefs", "refs/hidden")

     

       19
       +
       	if err := configureCmd.Run(); err != nil {

     

       20
        
       		return fmt.Errorf("failed to configure hidden refs: %w", err)

     

       21
        
       	}

     

       22

.tangled/workflows/build.yml

···

       2
        
         - event: ["push", "pull_request"]

     

       3
        
           branch: ["master"]

     

       4
        
       

     

       0
        
       
     

       0
        
       
     

       5
        
       dependencies:

     

       6
        
         nixpkgs:

     

       7
        
           - go

···

       2
        
         - event: ["push", "pull_request"]

     

       3
        
           branch: ["master"]

     

       4
        
       

     

       5
       +
       engine: nixery

     

       6
       +
       

     

       7
        
       dependencies:

     

       8
        
         nixpkgs:

     

       9
        
           - go

.tangled/workflows/fmt.yml

···

       2
        
         - event: ["push", "pull_request"]

     

       3
        
           branch: ["master"]

     

       4
        
       

     

       0
        
       
     

       0
        
       
     

       5
        
       steps:

     

       6
        
         - name: "Check formatting"

     

       7
        
           command: |

···

       2
        
         - event: ["push", "pull_request"]

     

       3
        
           branch: ["master"]

     

       4
        
       

     

       5
       +
       engine: nixery

     

       6
       +
       

     

       7
        
       steps:

     

       8
        
         - name: "Check formatting"

     

       9
        
           command: |

+1 -1

appview/pages/templates/strings/fragments/form.html

···

       13
        
               type="text"

     

       14
        
               id="filename"

     

       15
        
               name="filename"

     

       16
       -
               placeholder="Filename with extension"

     

       17
        
               required

     

       18
        
               value="{{ .String.Filename }}"

     

       19
        
               class="md:max-w-64 dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

···

       13
        
               type="text"

     

       14
        
               id="filename"

     

       15
        
               name="filename"

     

       16
       +
               placeholder="Filename"

     

       17
        
               required

     

       18
        
               value="{{ .String.Filename }}"

     

       19
        
               class="md:max-w-64 dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded"

+62

appview/pages/templates/user/settings/fragments/emailListing.html

···

       1
       +
       {{ define "user/settings/fragments/emailListing" }}

     

       2
       +
         {{ $root := index . 0 }}

     

       3
       +
         {{ $email := index . 1 }}

     

       4
       +
         <div id="email-{{$email.Address}}" class="flex items-center justify-between p-2">

     

       5
       +
           <div class="hover:no-underline flex flex-col gap-1 min-w-0 max-w-[80%]">

     

       6
       +
             <div class="flex items-center gap-2">

     

       7
       +
               {{ i "mail" "w-4 h-4 text-gray-500 dark:text-gray-400" }}

     

       8
       +
               <span class="font-bold">

     

       9
       +
                 {{ $email.Address }}

     

       10
       +
               </span>

     

       11
       +
               <div class="inline-flex items-center gap-1">

     

       12
       +
                 {{ if $email.Verified }}

     

       13
       +
                 <span class="text-xs bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 px-2 py-1 rounded">verified</span>

     

       14
       +
                 {{ else }}

     

       15
       +
                 <span class="text-xs bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 px-2 py-1 rounded">unverified</span>

     

       16
       +
                 {{ end }}

     

       17
       +
                 {{ if $email.Primary }}

     

       18
       +
                 <span class="text-xs bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200 px-2 py-1 rounded">primary</span>

     

       19
       +
                 {{ end }}

     

       20
       +
               </div>

     

       21
       +
             </div>

     

       22
       +
             <div class="flex text-sm flex-wrap text items-center gap-1 text-gray-500 dark:text-gray-400">

     

       23
       +
               <span>added {{ template "repo/fragments/time" $email.CreatedAt }}</span>

     

       24
       +
             </div>

     

       25
       +
           </div>

     

       26
       +
           <div class="flex gap-2 items-center">

     

       27
       +
             {{ if not $email.Verified }}

     

       28
       +
             <button

     

       29
       +
               class="btn flex gap-2 text-sm px-2 py-1"

     

       30
       +
               hx-post="/settings/emails/verify/resend"

     

       31
       +
               hx-swap="none"

     

       32
       +
               hx-vals='{"email": "{{ $email.Address }}"}'>

     

       33
       +
               {{ i "rotate-cw" "w-4 h-4" }}

     

       34
       +
               <span class="hidden md:inline">resend</span>

     

       35
       +
             </button>

     

       36
       +
             {{ end }}

     

       37
       +
             {{ if and (not $email.Primary) $email.Verified }}

     

       38
       +
             <button

     

       39
       +
               class="btn text-sm px-2 py-1 text-blue-500 hover:text-blue-700 dark:text-blue-400 dark:hover:text-blue-300"

     

       40
       +
               hx-post="/settings/emails/primary"

     

       41
       +
               hx-swap="none"

     

       42
       +
               hx-vals='{"email": "{{ $email.Address }}"}'>

     

       43
       +
               set as primary

     

       44
       +
             </button>

     

       45
       +
             {{ end }}

     

       46
       +
             {{ if not $email.Primary }}

     

       47
       +
             <button

     

       48
       +
               class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       49
       +
               title="Delete email"

     

       50
       +
               hx-delete="/settings/emails"

     

       51
       +
               hx-swap="none"

     

       52
       +
               hx-vals='{"email": "{{ $email.Address }}"}'

     

       53
       +
               hx-confirm="Are you sure you want to delete the email {{ $email.Address }}?"

     

       54
       +
             >

     

       55
       +
               {{ i "trash-2" "w-5 h-5" }}

     

       56
       +
               <span class="hidden md:inline">delete</span>

     

       57
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       58
       +
             </button>

     

       59
       +
             {{ end }}

     

       60
       +
           </div>

     

       61
       +
         </div>

     

       62
       +
       {{ end }}

+31

appview/pages/templates/user/settings/fragments/keyListing.html

···

       1
       +
       {{ define "user/settings/fragments/keyListing" }}

     

       2
       +
         {{ $root := index . 0 }}

     

       3
       +
         {{ $key := index . 1 }}

     

       4
       +
         <div id="key-{{$key.Name}}" class="flex items-center justify-between p-2">

     

       5
       +
           <div class="hover:no-underline flex flex-col gap-1 text min-w-0 max-w-[80%]">

     

       6
       +
           <div class="flex items-center gap-2">

     

       7
       +
             <span>{{ i "key" "w-4" "h-4" }}</span>

     

       8
       +
             <span class="font-bold">

     

       9
       +
               {{ $key.Name }}

     

       10
       +
             </span>

     

       11
       +
           </div>

     

       12
       +
             <span class="font-mono text-sm text-gray-500 dark:text-gray-400">

     

       13
       +
               {{ sshFingerprint $key.Key }}

     

       14
       +
             </span>

     

       15
       +
             <div class="flex flex-wrap text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       16
       +
               <span>added {{ template "repo/fragments/time" $key.Created }}</span>

     

       17
       +
             </div>

     

       18
       +
           </div>

     

       19
       +
           <button

     

       20
       +
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       21
       +
             title="Delete key"

     

       22
       +
             hx-delete="/settings/keys?name={{urlquery $key.Name}}&rkey={{urlquery $key.Rkey}}&key={{urlquery $key.Key}}"

     

       23
       +
             hx-swap="none"

     

       24
       +
             hx-confirm="Are you sure you want to delete the key {{ $key.Name }}?"

     

       25
       +
           >

     

       26
       +
             {{ i "trash-2" "w-5 h-5" }}

     

       27
       +
             <span class="hidden md:inline">delete</span>

     

       28
       +
             {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       29
       +
           </button>

     

       30
       +
         </div>

     

       31
       +
       {{ end }}

+16

appview/pages/templates/user/settings/fragments/sidebar.html

···

       1
       +
       {{ define "user/settings/fragments/sidebar" }}

     

       2
       +
         {{ $active := .Tab }}

     

       3
       +
         {{ $tabs := .Tabs }}

     

       4
       +
         <div class="sticky top-2 grid grid-cols-1 rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 shadow-inner">

     

       5
       +
           {{ $activeTab := "bg-white dark:bg-gray-700 drop-shadow-sm" }}

     

       6
       +
           {{ $inactiveTab := "bg-gray-100 dark:bg-gray-800" }}

     

       7
       +
           {{ range $tabs }}

     

       8
       +
           <a href="/settings/{{.Name}}" class="no-underline hover:no-underline hover:bg-gray-100/25 hover:dark:bg-gray-700/25">

     

       9
       +
             <div class="flex gap-3 items-center p-2 {{ if eq .Name $active }} {{ $activeTab }} {{ else }} {{ $inactiveTab }} {{ end }}">

     

       10
       +
               {{ i .Icon "size-4" }}

     

       11
       +
               {{ .Name }}

     

       12
       +
             </div>

     

       13
       +
           </a>

     

       14
       +
           {{ end }}

     

       15
       +
         </div>

     

       16
       +
       {{ end }}

+34

api/tangled/repocreate.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.create

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoCreateNSID = "sh.tangled.repo.create"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoCreate_Input is the input argument to a sh.tangled.repo.create call.

     

       18
       +
       type RepoCreate_Input struct {

     

       19
       +
       	// defaultBranch: Default branch to push to

     

       20
       +
       	DefaultBranch *string `json:"defaultBranch,omitempty" cborgen:"defaultBranch,omitempty"`

     

       21
       +
       	// rkey: Rkey of the repository record

     

       22
       +
       	Rkey string `json:"rkey" cborgen:"rkey"`

     

       23
       +
       	// source: A source URL to clone from, populate this when forking or importing a repository.

     

       24
       +
       	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       +
       }

     

       26
       +
       

     

       27
       +
       // RepoCreate calls the XRPC method "sh.tangled.repo.create".

     

       28
       +
       func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) error {

     

       29
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, nil); err != nil {

     

       30
       +
       		return err

     

       31
       +
       	}

     

       32
       +
       

     

       33
       +
       	return nil

     

       34
       +
       }

+45

api/tangled/repoforkStatus.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.forkStatus

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoForkStatusNSID = "sh.tangled.repo.forkStatus"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoForkStatus_Input is the input argument to a sh.tangled.repo.forkStatus call.

     

       18
       +
       type RepoForkStatus_Input struct {

     

       19
       +
       	// branch: Branch to check status for

     

       20
       +
       	Branch string `json:"branch" cborgen:"branch"`

     

       21
       +
       	// did: DID of the fork owner

     

       22
       +
       	Did string `json:"did" cborgen:"did"`

     

       23
       +
       	// hiddenRef: Hidden ref to use for comparison

     

       24
       +
       	HiddenRef string `json:"hiddenRef" cborgen:"hiddenRef"`

     

       25
       +
       	// name: Name of the forked repository

     

       26
       +
       	Name string `json:"name" cborgen:"name"`

     

       27
       +
       	// source: Source repository URL

     

       28
       +
       	Source string `json:"source" cborgen:"source"`

     

       29
       +
       }

     

       30
       +
       

     

       31
       +
       // RepoForkStatus_Output is the output of a sh.tangled.repo.forkStatus call.

     

       32
       +
       type RepoForkStatus_Output struct {

     

       33
       +
       	// status: Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch

     

       34
       +
       	Status int64 `json:"status" cborgen:"status"`

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       // RepoForkStatus calls the XRPC method "sh.tangled.repo.forkStatus".

     

       38
       +
       func RepoForkStatus(ctx context.Context, c util.LexClient, input *RepoForkStatus_Input) (*RepoForkStatus_Output, error) {

     

       39
       +
       	var out RepoForkStatus_Output

     

       40
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.forkStatus", nil, input, &out); err != nil {

     

       41
       +
       		return nil, err

     

       42
       +
       	}

     

       43
       +
       

     

       44
       +
       	return &out, nil

     

       45
       +
       }

+36

api/tangled/repoforkSync.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.forkSync

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoForkSyncNSID = "sh.tangled.repo.forkSync"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoForkSync_Input is the input argument to a sh.tangled.repo.forkSync call.

     

       18
       +
       type RepoForkSync_Input struct {

     

       19
       +
       	// branch: Branch to sync

     

       20
       +
       	Branch string `json:"branch" cborgen:"branch"`

     

       21
       +
       	// did: DID of the fork owner

     

       22
       +
       	Did string `json:"did" cborgen:"did"`

     

       23
       +
       	// name: Name of the forked repository

     

       24
       +
       	Name string `json:"name" cborgen:"name"`

     

       25
       +
       	// source: AT-URI of the source repository

     

       26
       +
       	Source string `json:"source" cborgen:"source"`

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       // RepoForkSync calls the XRPC method "sh.tangled.repo.forkSync".

     

       30
       +
       func RepoForkSync(ctx context.Context, c util.LexClient, input *RepoForkSync_Input) error {

     

       31
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.forkSync", nil, input, nil); err != nil {

     

       32
       +
       		return err

     

       33
       +
       	}

     

       34
       +
       

     

       35
       +
       	return nil

     

       36
       +
       }

+45

api/tangled/repohiddenRef.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.hiddenRef

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoHiddenRefNSID = "sh.tangled.repo.hiddenRef"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoHiddenRef_Input is the input argument to a sh.tangled.repo.hiddenRef call.

     

       18
       +
       type RepoHiddenRef_Input struct {

     

       19
       +
       	// forkRef: Fork reference name

     

       20
       +
       	ForkRef string `json:"forkRef" cborgen:"forkRef"`

     

       21
       +
       	// remoteRef: Remote reference name

     

       22
       +
       	RemoteRef string `json:"remoteRef" cborgen:"remoteRef"`

     

       23
       +
       	// repo: AT-URI of the repository

     

       24
       +
       	Repo string `json:"repo" cborgen:"repo"`

     

       25
       +
       }

     

       26
       +
       

     

       27
       +
       // RepoHiddenRef_Output is the output of a sh.tangled.repo.hiddenRef call.

     

       28
       +
       type RepoHiddenRef_Output struct {

     

       29
       +
       	// error: Error message if creation failed

     

       30
       +
       	Error *string `json:"error,omitempty" cborgen:"error,omitempty"`

     

       31
       +
       	// ref: The created hidden ref name

     

       32
       +
       	Ref *string `json:"ref,omitempty" cborgen:"ref,omitempty"`

     

       33
       +
       	// success: Whether the hidden ref was created successfully

     

       34
       +
       	Success bool `json:"success" cborgen:"success"`

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       // RepoHiddenRef calls the XRPC method "sh.tangled.repo.hiddenRef".

     

       38
       +
       func RepoHiddenRef(ctx context.Context, c util.LexClient, input *RepoHiddenRef_Input) (*RepoHiddenRef_Output, error) {

     

       39
       +
       	var out RepoHiddenRef_Output

     

       40
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.hiddenRef", nil, input, &out); err != nil {

     

       41
       +
       		return nil, err

     

       42
       +
       	}

     

       43
       +
       

     

       44
       +
       	return &out, nil

     

       45
       +
       }

+44

api/tangled/repomerge.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.merge

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoMergeNSID = "sh.tangled.repo.merge"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoMerge_Input is the input argument to a sh.tangled.repo.merge call.

     

       18
       +
       type RepoMerge_Input struct {

     

       19
       +
       	// authorEmail: Author email for the merge commit

     

       20
       +
       	AuthorEmail *string `json:"authorEmail,omitempty" cborgen:"authorEmail,omitempty"`

     

       21
       +
       	// authorName: Author name for the merge commit

     

       22
       +
       	AuthorName *string `json:"authorName,omitempty" cborgen:"authorName,omitempty"`

     

       23
       +
       	// branch: Target branch to merge into

     

       24
       +
       	Branch string `json:"branch" cborgen:"branch"`

     

       25
       +
       	// commitBody: Additional commit message body

     

       26
       +
       	CommitBody *string `json:"commitBody,omitempty" cborgen:"commitBody,omitempty"`

     

       27
       +
       	// commitMessage: Merge commit message

     

       28
       +
       	CommitMessage *string `json:"commitMessage,omitempty" cborgen:"commitMessage,omitempty"`

     

       29
       +
       	// did: DID of the repository owner

     

       30
       +
       	Did string `json:"did" cborgen:"did"`

     

       31
       +
       	// name: Name of the repository

     

       32
       +
       	Name string `json:"name" cborgen:"name"`

     

       33
       +
       	// patch: Patch content to merge

     

       34
       +
       	Patch string `json:"patch" cborgen:"patch"`

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       // RepoMerge calls the XRPC method "sh.tangled.repo.merge".

     

       38
       +
       func RepoMerge(ctx context.Context, c util.LexClient, input *RepoMerge_Input) error {

     

       39
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.merge", nil, input, nil); err != nil {

     

       40
       +
       		return err

     

       41
       +
       	}

     

       42
       +
       

     

       43
       +
       	return nil

     

       44
       +
       }

+57

api/tangled/repomergeCheck.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.mergeCheck

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoMergeCheckNSID = "sh.tangled.repo.mergeCheck"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoMergeCheck_ConflictInfo is a "conflictInfo" in the sh.tangled.repo.mergeCheck schema.

     

       18
       +
       type RepoMergeCheck_ConflictInfo struct {

     

       19
       +
       	// filename: Name of the conflicted file

     

       20
       +
       	Filename string `json:"filename" cborgen:"filename"`

     

       21
       +
       	// reason: Reason for the conflict

     

       22
       +
       	Reason string `json:"reason" cborgen:"reason"`

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       // RepoMergeCheck_Input is the input argument to a sh.tangled.repo.mergeCheck call.

     

       26
       +
       type RepoMergeCheck_Input struct {

     

       27
       +
       	// branch: Target branch to merge into

     

       28
       +
       	Branch string `json:"branch" cborgen:"branch"`

     

       29
       +
       	// did: DID of the repository owner

     

       30
       +
       	Did string `json:"did" cborgen:"did"`

     

       31
       +
       	// name: Name of the repository

     

       32
       +
       	Name string `json:"name" cborgen:"name"`

     

       33
       +
       	// patch: Patch or pull request to check for merge conflicts

     

       34
       +
       	Patch string `json:"patch" cborgen:"patch"`

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       // RepoMergeCheck_Output is the output of a sh.tangled.repo.mergeCheck call.

     

       38
       +
       type RepoMergeCheck_Output struct {

     

       39
       +
       	// conflicts: List of files with merge conflicts

     

       40
       +
       	Conflicts []*RepoMergeCheck_ConflictInfo `json:"conflicts,omitempty" cborgen:"conflicts,omitempty"`

     

       41
       +
       	// error: Error message if check failed

     

       42
       +
       	Error *string `json:"error,omitempty" cborgen:"error,omitempty"`

     

       43
       +
       	// is_conflicted: Whether the merge has conflicts

     

       44
       +
       	Is_conflicted bool `json:"is_conflicted" cborgen:"is_conflicted"`

     

       45
       +
       	// message: Additional message about the merge check

     

       46
       +
       	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`

     

       47
       +
       }

     

       48
       +
       

     

       49
       +
       // RepoMergeCheck calls the XRPC method "sh.tangled.repo.mergeCheck".

     

       50
       +
       func RepoMergeCheck(ctx context.Context, c util.LexClient, input *RepoMergeCheck_Input) (*RepoMergeCheck_Output, error) {

     

       51
       +
       	var out RepoMergeCheck_Output

     

       52
       +
       	if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.mergeCheck", nil, input, &out); err != nil {

     

       53
       +
       		return nil, err

     

       54
       +
       	}

     

       55
       +
       

     

       56
       +
       	return &out, nil

     

       57
       +
       }

+24

lexicons/knot/knot.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.knot",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "any",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "createdAt"

     

       14
       +
               ],

     

       15
       +
               "properties": {

     

       16
       +
                 "createdAt": {

     

       17
       +
                   "type": "string",

     

       18
       +
                   "format": "datetime"

     

       19
       +
                 }

     

       20
       +
               }

     

       21
       +
             }

     

       22
       +
           }

     

       23
       +
         }

     

       24
       +
       }

+33

lexicons/repo/create.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.create",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Create a new repository",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "rkey"

     

       14
       +
                 ],

     

       15
       +
                 "properties": {

     

       16
       +
                   "rkey": {

     

       17
       +
                     "type": "string",

     

       18
       +
                     "description": "Rkey of the repository record"

     

       19
       +
                   },

     

       20
       +
                   "defaultBranch": {

     

       21
       +
                     "type": "string",

     

       22
       +
                     "description": "Default branch to push to"

     

       23
       +
                   },

     

       24
       +
                   "source": {

     

       25
       +
                     "type": "string",

     

       26
       +
                     "description": "A source URL to clone from, populate this when forking or importing a repository."

     

       27
       +
                   }

     

       28
       +
                 }

     

       29
       +
               }

     

       30
       +
             }

     

       31
       +
           }

     

       32
       +
         }

     

       33
       +
       }

+53

lexicons/repo/forkStatus.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.forkStatus",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Check fork status relative to upstream source",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": ["did", "name", "source", "branch", "hiddenRef"],

     

       13
       +
                 "properties": {

     

       14
       +
                   "did": {

     

       15
       +
                     "type": "string",

     

       16
       +
                     "format": "did",

     

       17
       +
                     "description": "DID of the fork owner"

     

       18
       +
                   },

     

       19
       +
                   "name": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "description": "Name of the forked repository"

     

       22
       +
                   },

     

       23
       +
                   "source": {

     

       24
       +
                     "type": "string",

     

       25
       +
                     "description": "Source repository URL"

     

       26
       +
                   },

     

       27
       +
                   "branch": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Branch to check status for"

     

       30
       +
                   },

     

       31
       +
                   "hiddenRef": {

     

       32
       +
                     "type": "string",

     

       33
       +
                     "description": "Hidden ref to use for comparison"

     

       34
       +
                   }

     

       35
       +
                 }

     

       36
       +
               }

     

       37
       +
             },

     

       38
       +
             "output": {

     

       39
       +
               "encoding": "application/json",

     

       40
       +
               "schema": {

     

       41
       +
                 "type": "object",

     

       42
       +
                 "required": ["status"],

     

       43
       +
                 "properties": {

     

       44
       +
                   "status": {

     

       45
       +
                     "type": "integer",

     

       46
       +
                     "description": "Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch"

     

       47
       +
                   }

     

       48
       +
                 }

     

       49
       +
               }

     

       50
       +
             }

     

       51
       +
           }

     

       52
       +
         }

     

       53
       +
       }

+42

lexicons/repo/forkSync.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.forkSync",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Sync a forked repository with its upstream source",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "did",

     

       14
       +
                   "source",

     

       15
       +
                   "name",

     

       16
       +
                   "branch"

     

       17
       +
                 ],

     

       18
       +
                 "properties": {

     

       19
       +
                   "did": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "format": "did",

     

       22
       +
                     "description": "DID of the fork owner"

     

       23
       +
                   },

     

       24
       +
                   "source": {

     

       25
       +
                     "type": "string",

     

       26
       +
                     "format": "at-uri",

     

       27
       +
                     "description": "AT-URI of the source repository"

     

       28
       +
                   },

     

       29
       +
                   "name": {

     

       30
       +
                     "type": "string",

     

       31
       +
                     "description": "Name of the forked repository"

     

       32
       +
                   },

     

       33
       +
                   "branch": {

     

       34
       +
                     "type": "string",

     

       35
       +
                     "description": "Branch to sync"

     

       36
       +
                   }

     

       37
       +
                 }

     

       38
       +
               }

     

       39
       +
             }

     

       40
       +
           }

     

       41
       +
         }

     

       42
       +
       }

+59

lexicons/repo/hiddenRef.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.hiddenRef",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Create a hidden ref in a repository",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "repo",

     

       14
       +
                   "forkRef",

     

       15
       +
                   "remoteRef"

     

       16
       +
                 ],

     

       17
       +
                 "properties": {

     

       18
       +
                   "repo": {

     

       19
       +
                     "type": "string",

     

       20
       +
                     "format": "at-uri",

     

       21
       +
                     "description": "AT-URI of the repository"

     

       22
       +
                   },

     

       23
       +
                   "forkRef": {

     

       24
       +
                     "type": "string",

     

       25
       +
                     "description": "Fork reference name"

     

       26
       +
                   },

     

       27
       +
                   "remoteRef": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Remote reference name"

     

       30
       +
                   }

     

       31
       +
                 }

     

       32
       +
               }

     

       33
       +
             },

     

       34
       +
             "output": {

     

       35
       +
               "encoding": "application/json",

     

       36
       +
               "schema": {

     

       37
       +
                 "type": "object",

     

       38
       +
                 "required": [

     

       39
       +
                   "success"

     

       40
       +
                 ],

     

       41
       +
                 "properties": {

     

       42
       +
                   "success": {

     

       43
       +
                     "type": "boolean",

     

       44
       +
                     "description": "Whether the hidden ref was created successfully"

     

       45
       +
                   },

     

       46
       +
                   "ref": {

     

       47
       +
                     "type": "string",

     

       48
       +
                     "description": "The created hidden ref name"

     

       49
       +
                   },

     

       50
       +
                   "error": {

     

       51
       +
                     "type": "string",

     

       52
       +
                     "description": "Error message if creation failed"

     

       53
       +
                   }

     

       54
       +
                 }

     

       55
       +
               }

     

       56
       +
             }

     

       57
       +
           }

     

       58
       +
         }

     

       59
       +
       }

+52

lexicons/repo/merge.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.merge",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Merge a patch into a repository branch",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": ["did", "name", "patch", "branch"],

     

       13
       +
                 "properties": {

     

       14
       +
                   "did": {

     

       15
       +
                     "type": "string",

     

       16
       +
                     "format": "did",

     

       17
       +
                     "description": "DID of the repository owner"

     

       18
       +
                   },

     

       19
       +
                   "name": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "description": "Name of the repository"

     

       22
       +
                   },

     

       23
       +
                   "patch": {

     

       24
       +
                     "type": "string",

     

       25
       +
                     "description": "Patch content to merge"

     

       26
       +
                   },

     

       27
       +
                   "branch": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Target branch to merge into"

     

       30
       +
                   },

     

       31
       +
                   "authorName": {

     

       32
       +
                     "type": "string",

     

       33
       +
                     "description": "Author name for the merge commit"

     

       34
       +
                   },

     

       35
       +
                   "authorEmail": {

     

       36
       +
                     "type": "string",

     

       37
       +
                     "description": "Author email for the merge commit"

     

       38
       +
                   },

     

       39
       +
                   "commitBody": {

     

       40
       +
                     "type": "string",

     

       41
       +
                     "description": "Additional commit message body"

     

       42
       +
                   },

     

       43
       +
                   "commitMessage": {

     

       44
       +
                     "type": "string",

     

       45
       +
                     "description": "Merge commit message"

     

       46
       +
                   }

     

       47
       +
                 }

     

       48
       +
               }

     

       49
       +
             }

     

       50
       +
           }

     

       51
       +
         }

     

       52
       +
       }

+79

lexicons/repo/mergeCheck.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.mergeCheck",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "procedure",

     

       7
       +
             "description": "Check if a merge is possible between two branches",

     

       8
       +
             "input": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": ["did", "name", "patch", "branch"],

     

       13
       +
                 "properties": {

     

       14
       +
                   "did": {

     

       15
       +
                     "type": "string",

     

       16
       +
                     "format": "did",

     

       17
       +
                     "description": "DID of the repository owner"

     

       18
       +
                   },

     

       19
       +
                   "name": {

     

       20
       +
                     "type": "string",

     

       21
       +
                     "description": "Name of the repository"

     

       22
       +
                   },

     

       23
       +
                   "patch": {

     

       24
       +
                     "type": "string",

     

       25
       +
                     "description": "Patch or pull request to check for merge conflicts"

     

       26
       +
                   },

     

       27
       +
                   "branch": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Target branch to merge into"

     

       30
       +
                   }

     

       31
       +
                 }

     

       32
       +
               }

     

       33
       +
             },

     

       34
       +
             "output": {

     

       35
       +
               "encoding": "application/json",

     

       36
       +
               "schema": {

     

       37
       +
                 "type": "object",

     

       38
       +
                 "required": ["is_conflicted"],

     

       39
       +
                 "properties": {

     

       40
       +
                   "is_conflicted": {

     

       41
       +
                     "type": "boolean",

     

       42
       +
                     "description": "Whether the merge has conflicts"

     

       43
       +
                   },

     

       44
       +
                   "conflicts": {

     

       45
       +
                     "type": "array",

     

       46
       +
                     "description": "List of files with merge conflicts",

     

       47
       +
                     "items": {

     

       48
       +
                       "type": "ref",

     

       49
       +
                       "ref": "#conflictInfo"

     

       50
       +
                     }

     

       51
       +
                   },

     

       52
       +
                   "message": {

     

       53
       +
                     "type": "string",

     

       54
       +
                     "description": "Additional message about the merge check"

     

       55
       +
                   },

     

       56
       +
                   "error": {

     

       57
       +
                     "type": "string",

     

       58
       +
                     "description": "Error message if check failed"

     

       59
       +
                   }

     

       60
       +
                 }

     

       61
       +
               }

     

       62
       +
             }

     

       63
       +
           },

     

       64
       +
           "conflictInfo": {

     

       65
       +
             "type": "object",

     

       66
       +
             "required": ["filename", "reason"],

     

       67
       +
             "properties": {

     

       68
       +
               "filename": {

     

       69
       +
                 "type": "string",

     

       70
       +
                 "description": "Name of the conflicted file"

     

       71
       +
               },

     

       72
       +
               "reason": {

     

       73
       +
                 "type": "string",

     

       74
       +
                 "description": "Reason for the conflict"

     

       75
       +
               }

     

       76
       +
             }

     

       77
       +
           }

     

       78
       +
         }

     

       79
       +
       }

+22

api/tangled/tangledknot.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.knot

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	KnotNSID = "sh.tangled.knot"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.knot", &Knot{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: Knot

     

       19
       +
       type Knot struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.knot" cborgen:"$type,const=sh.tangled.knot"`

     

       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
       +
       }

+93 -28

appview/pages/templates/knots/dashboard.html

···

       1
       -
       {{ define "title" }}{{ .Registration.Domain }}{{ end }}

     

       2
        
       

     

       3
        
       {{ define "content" }}

     

       4
       -
         <div class="px-6 py-4">

     

       5
       -
           <div class="flex justify-between items-center">

     

       6
       -
             <div id="left-side" class="flex gap-2 items-center">

     

       7
       -
               <h1 class="text-xl font-bold dark:text-white">

     

       8
       -
                 {{ .Registration.Domain }}

     

       9
       -
               </h1>

     

       10
       -
               <span class="text-gray-500 text-base">

     

       11
       -
                 {{ template "repo/fragments/shortTimeAgo" .Registration.Created }}

     

       12
       -
               </span>

     

       13
       -
             </div>

     

       14
       -
             <div id="right-side" class="flex gap-2">

     

       15
       -
               {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       16
       -
               {{ if .Registration.Registered }}

     

       17
       -
                 <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span>

     

       18
        
                 {{ template "knots/fragments/addMemberModal" .Registration }}

     

       19
       -
               {{ else }}

     

       20
       -
                 <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} pending</span>

     

       21
        
               {{ end }}

     

       22
       -
             </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
           </div>

     

       24
       -
           <div id="operation-error" class="dark:text-red-400"></div>

     

       25
        
         </div>

     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
       -
         {{ if .Members }}

     

       28
       -
           <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       29
       -
             <div class="flex flex-col gap-2">

     

       30
       -
               {{ block "knotMember" . }} {{ end }}

     

       31
       -
             </div>

     

       32
       -
           </section>

     

       33
       -
         {{ end }}

     

       34
        
       {{ end }}

     

       35
        
       

     

       36
       -
       {{ define "knotMember" }}

     

       0
        
       
     

       37
        
         {{ range .Members }}

     

       38
        
           <div>

     

       39
        
             <div class="flex justify-between items-center">

     
···

       41
        
                 {{ template "user/fragments/picHandleLink" . }}

     

       42
        
                 <span class="ml-2 font-mono text-gray-500">{{.}}</span>

     

       43
        
               </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       44
        
             </div>

     

       45
        
             <div class="ml-2 pl-2 pt-2 border-l border-gray-200 dark:border-gray-700">

     

       46
        
               {{ $repos := index $.Repos . }}

     
···

       53
        
                 </div>

     

       54
        
               {{ else }}

     

       55
        
                 <div class="text-gray-500 dark:text-gray-400">

     

       56
       -
                   No repositories created yet.

     

       57
        
                 </div>

     

       58
        
               {{ end }}

     

       59
        
             </div>

     

       60
        
           </div>

     

       61
        
         {{ end }}

     

       62
        
       {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
       +
       {{ define "title" }}{{ .Registration.Domain }} &middot; knots{{ end }}

     

       2
        
       

     

       3
        
       {{ define "content" }}

     

       4
       +
       <div class="px-6 py-4">

     

       5
       +
         <div class="flex justify-between items-center">

     

       6
       +
           <h1 class="text-xl font-bold dark:text-white">{{ .Registration.Domain }}</h1>

     

       7
       +
           <div id="right-side" class="flex gap-2">

     

       8
       +
             {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2" }}

     

       9
       +
             {{ $isOwner := and .LoggedInUser (eq .LoggedInUser.Did .Registration.ByDid)  }}

     

       10
       +
             {{ if .Registration.IsRegistered }}

     

       11
       +
               <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span>

     

       12
       +
               {{ if $isOwner }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
                 {{ template "knots/fragments/addMemberModal" .Registration }}

     

       0
        
       
     

       0
        
       
     

       14
        
               {{ end }}

     

       15
       +
             {{ else if .Registration.IsReadOnly }}

     

       16
       +
               <span class="bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 {{$style}}">

     

       17
       +
                 {{ i "shield-alert" "w-4 h-4" }} read-only

     

       18
       +
               </span>

     

       19
       +
               {{ if $isOwner }}

     

       20
       +
                 {{ block "retryButton" .Registration }} {{ end }}

     

       21
       +
               {{ end }}

     

       22
       +
             {{ else }}

     

       23
       +
               <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} unverified</span>

     

       24
       +
               {{ if $isOwner }}

     

       25
       +
                 {{ block "retryButton" .Registration }} {{ end }}

     

       26
       +
               {{ end }}

     

       27
       +
             {{ end }}

     

       28
       +
       

     

       29
       +
             {{ if $isOwner }}

     

       30
       +
               {{ block "deleteButton" .Registration }} {{ end }}

     

       31
       +
             {{ end }}

     

       32
        
           </div>

     

       0
        
       
     

       33
        
         </div>

     

       34
       +
         <div id="operation-error" class="dark:text-red-400"></div>

     

       35
       +
       </div>

     

       36
        
       

     

       37
       +
       {{ if .Members }}

     

       38
       +
         <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       39
       +
           <div class="flex flex-col gap-2">

     

       40
       +
             {{ block "member" . }} {{ end }}

     

       41
       +
           </div>

     

       42
       +
         </section>

     

       43
       +
       {{ end }}

     

       44
        
       {{ end }}

     

       45
        
       

     

       46
       +
       

     

       47
       +
       {{ define "member" }}

     

       48
        
         {{ range .Members }}

     

       49
        
           <div>

     

       50
        
             <div class="flex justify-between items-center">

     
···

       52
        
                 {{ template "user/fragments/picHandleLink" . }}

     

       53
        
                 <span class="ml-2 font-mono text-gray-500">{{.}}</span>

     

       54
        
               </div>

     

       55
       +
               {{ if ne $.LoggedInUser.Did . }}

     

       56
       +
                 {{ block "removeMemberButton" (list $ . ) }} {{ end }}

     

       57
       +
               {{ end }}

     

       58
        
             </div>

     

       59
        
             <div class="ml-2 pl-2 pt-2 border-l border-gray-200 dark:border-gray-700">

     

       60
        
               {{ $repos := index $.Repos . }}

     
···

       67
        
                 </div>

     

       68
        
               {{ else }}

     

       69
        
                 <div class="text-gray-500 dark:text-gray-400">

     

       70
       +
                   No repositories configured yet.

     

       71
        
                 </div>

     

       72
        
               {{ end }}

     

       73
        
             </div>

     

       74
        
           </div>

     

       75
        
         {{ end }}

     

       76
        
       {{ end }}

     

       77
       +
       

     

       78
       +
       {{ define "deleteButton" }}

     

       79
       +
         <button

     

       80
       +
           class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       81
       +
           title="Delete knot"

     

       82
       +
           hx-delete="/knots/{{ .Domain }}"

     

       83
       +
           hx-swap="outerHTML"

     

       84
       +
           hx-confirm="Are you sure you want to delete the knot '{{ .Domain }}'?"

     

       85
       +
           hx-headers='{"shouldRedirect": "true"}'

     

       86
       +
         >

     

       87
       +
           {{ i "trash-2" "w-5 h-5" }}

     

       88
       +
           <span class="hidden md:inline">delete</span> 

     

       89
       +
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       90
       +
         </button>

     

       91
       +
       {{ end }}

     

       92
       +
       

     

       93
       +
       

     

       94
       +
       {{ define "retryButton" }}

     

       95
       +
         <button

     

       96
       +
           class="btn gap-2 group"

     

       97
       +
           title="Retry knot verification"

     

       98
       +
           hx-post="/knots/{{ .Domain }}/retry"

     

       99
       +
           hx-swap="none"

     

       100
       +
           hx-headers='{"shouldRefresh": "true"}'

     

       101
       +
         >

     

       102
       +
           {{ i "rotate-ccw" "w-5 h-5" }}

     

       103
       +
           <span class="hidden md:inline">retry</span> 

     

       104
       +
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       105
       +
         </button>

     

       106
       +
       {{ end }}

     

       107
       +
       

     

       108
       +
       

     

       109
       +
       {{ define "removeMemberButton" }}

     

       110
       +
         {{ $root := index . 0 }}

     

       111
       +
         {{ $member := index . 1 }}

     

       112
       +
         {{ $memberHandle := resolve $member }}

     

       113
       +
           <button

     

       114
       +
             class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       115
       +
             title="Remove member"

     

       116
       +
             hx-post="/knots/{{ $root.Registration.Domain }}/remove"

     

       117
       +
             hx-swap="none"

     

       118
       +
             hx-vals='{"member": "{{$member}}" }'

     

       119
       +
             hx-confirm="Are you sure you want to remove {{ $memberHandle }} from this knot?"

     

       120
       +
           >

     

       121
       +
             {{ i "user-minus" "w-4 h-4" }}

     

       122
       +
             remove

     

       123
       +
             {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       124
       +
           </button>

     

       125
       +
       {{ end }}

     

       126
       +
       

     

       127
       +

+6 -7

appview/pages/templates/knots/fragments/addMemberModal.html

···

       1
        
       {{ define "knots/fragments/addMemberModal" }}

     

       2
        
         <button

     

       3
        
           class="btn gap-2 group"

     

       4
       -
           title="Add member to this spindle"

     

       5
        
           popovertarget="add-member-{{ .Id }}"

     

       6
        
           popovertargetaction="toggle"

     

       7
        
         >

     
···

       20
        
       

     

       21
        
       {{ define "addKnotMemberPopover" }}

     

       22
        
       <form

     

       23
       -
         hx-put="/knots/{{ .Domain }}/member"

     

       24
        
         hx-indicator="#spinner"

     

       25
        
         hx-swap="none"

     

       26
        
         class="flex flex-col gap-2"

     
···

       28
        
         <label for="member-did-{{ .Id }}" class="uppercase p-0">

     

       29
        
           ADD MEMBER

     

       30
        
         </label>

     

       31
       -
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can create repositories on this knot.</p>

     

       32
        
         <input

     

       33
        
           type="text"

     

       34
        
           id="member-did-{{ .Id }}"

     

       35
       -
           name="subject"

     

       36
        
           required

     

       37
        
           placeholder="@foo.bsky.social"

     

       38
        
         />

     

       39
        
         <div class="flex gap-2 pt-2">

     

       40
       -
           <button

     

       41
        
             type="button"

     

       42
        
             popovertarget="add-member-{{ .Id }}"

     

       43
        
             popovertargetaction="hide"

     
···

       54
        
         </div>

     

       55
        
         <div id="add-member-error-{{ .Id }}" class="text-red-500 dark:text-red-400"></div>

     

       56
        
       </form>

     

       57
       -
       {{ end }}

     

       58
       -

···

       1
        
       {{ define "knots/fragments/addMemberModal" }}

     

       2
        
         <button

     

       3
        
           class="btn gap-2 group"

     

       4
       +
           title="Add member to this knot"

     

       5
        
           popovertarget="add-member-{{ .Id }}"

     

       6
        
           popovertargetaction="toggle"

     

       7
        
         >

     
···

       20
        
       

     

       21
        
       {{ define "addKnotMemberPopover" }}

     

       22
        
       <form

     

       23
       +
         hx-post="/knots/{{ .Domain }}/add"

     

       24
        
         hx-indicator="#spinner"

     

       25
        
         hx-swap="none"

     

       26
        
         class="flex flex-col gap-2"

     
···

       28
        
         <label for="member-did-{{ .Id }}" class="uppercase p-0">

     

       29
        
           ADD MEMBER

     

       30
        
         </label>

     

       31
       +
         <p class="text-sm text-gray-500 dark:text-gray-400">Members can create repositories and run workflows on this knot.</p>

     

       32
        
         <input

     

       33
        
           type="text"

     

       34
        
           id="member-did-{{ .Id }}"

     

       35
       +
           name="member"

     

       36
        
           required

     

       37
        
           placeholder="@foo.bsky.social"

     

       38
        
         />

     

       39
        
         <div class="flex gap-2 pt-2">

     

       40
       +
           <button 

     

       41
        
             type="button"

     

       42
        
             popovertarget="add-member-{{ .Id }}"

     

       43
        
             popovertargetaction="hide"

     
···

       54
        
         </div>

     

       55
        
         <div id="add-member-error-{{ .Id }}" class="text-red-500 dark:text-red-400"></div>

     

       56
        
       </form>

     

       57
       +
       {{ end }}
     

       0

+2 -2

appview/pages/templates/spindles/fragments/addMemberModal.html

···

       14
        
           id="add-member-{{ .Instance }}"

     

       15
        
           popover

     

       16
        
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       17
       -
           {{ block "addMemberPopover" . }} {{ end }}

     

       18
        
         </div>

     

       19
        
       {{ end }}

     

       20
        
       

     

       21
       -
       {{ define "addMemberPopover" }}

     

       22
        
       <form

     

       23
        
         hx-post="/spindles/{{ .Instance }}/add"

     

       24
        
         hx-indicator="#spinner"

···

       14
        
           id="add-member-{{ .Instance }}"

     

       15
        
           popover

     

       16
        
           class="bg-white w-full md:w-96 dark:bg-gray-800 p-4 rounded border border-gray-200 dark:border-gray-700 drop-shadow dark:text-white backdrop:bg-gray-400/50 dark:backdrop:bg-gray-800/50">

     

       17
       +
           {{ block "addSpindleMemberPopover" . }} {{ end }}

     

       18
        
         </div>

     

       19
        
       {{ end }}

     

       20
        
       

     

       21
       +
       {{ define "addSpindleMemberPopover" }}

     

       22
        
       <form

     

       23
        
         hx-post="/spindles/{{ .Instance }}/add"

     

       24
        
         hx-indicator="#spinner"

-53

knotserver/middleware.go

···

       1
       -
       package knotserver

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"crypto/hmac"

     

       5
       -
       	"crypto/sha256"

     

       6
       -
       	"encoding/hex"

     

       7
       -
       	"net/http"

     

       8
       -
       	"time"

     

       9
       -
       )

     

       10
       -
       

     

       11
       -
       func (h *Handle) VerifySignature(next http.Handler) http.Handler {

     

       12
       -
       	if h.c.Server.Dev {

     

       13
       -
       		return next

     

       14
       -
       	}

     

       15
       -
       	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       16
       -
       		signature := r.Header.Get("X-Signature")

     

       17
       -
       		if signature == "" || !h.verifyHMAC(signature, r) {

     

       18
       -
       			writeError(w, "signature verification failed", http.StatusForbidden)

     

       19
       -
       			return

     

       20
       -
       		}

     

       21
       -
       		next.ServeHTTP(w, r)

     

       22
       -
       	})

     

       23
       -
       }

     

       24
       -
       

     

       25
       -
       func (h *Handle) verifyHMAC(signature string, r *http.Request) bool {

     

       26
       -
       	secret := h.c.Server.Secret

     

       27
       -
       	timestamp := r.Header.Get("X-Timestamp")

     

       28
       -
       	if timestamp == "" {

     

       29
       -
       		return false

     

       30
       -
       	}

     

       31
       -
       

     

       32
       -
       	// Verify that the timestamp is not older than a minute

     

       33
       -
       	reqTime, err := time.Parse(time.RFC3339, timestamp)

     

       34
       -
       	if err != nil {

     

       35
       -
       		return false

     

       36
       -
       	}

     

       37
       -
       	if time.Since(reqTime) > time.Minute {

     

       38
       -
       		return false

     

       39
       -
       	}

     

       40
       -
       

     

       41
       -
       	message := r.Method + r.URL.Path + timestamp

     

       42
       -
       

     

       43
       -
       	mac := hmac.New(sha256.New, []byte(secret))

     

       44
       -
       	mac.Write([]byte(message))

     

       45
       -
       	expectedMAC := mac.Sum(nil)

     

       46
       -
       

     

       47
       -
       	signatureBytes, err := hex.DecodeString(signature)

     

       48
       -
       	if err != nil {

     

       49
       -
       		return false

     

       50
       -
       	}

     

       51
       -
       

     

       52
       -
       	return hmac.Equal(signatureBytes, expectedMAC)

     

       53
       -
       }

-299

knotclient/signer.go

···

       1
       -
       package knotclient

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"bytes"

     

       5
       -
       	"crypto/hmac"

     

       6
       -
       	"crypto/sha256"

     

       7
       -
       	"encoding/hex"

     

       8
       -
       	"encoding/json"

     

       9
       -
       	"fmt"

     

       10
       -
       	"net/http"

     

       11
       -
       	"net/url"

     

       12
       -
       	"time"

     

       13
       -
       

     

       14
       -
       	"tangled.sh/tangled.sh/core/types"

     

       15
       -
       )

     

       16
       -
       

     

       17
       -
       type SignerTransport struct {

     

       18
       -
       	Secret string

     

       19
       -
       }

     

       20
       -
       

     

       21
       -
       func (s SignerTransport) RoundTrip(req *http.Request) (*http.Response, error) {

     

       22
       -
       	timestamp := time.Now().Format(time.RFC3339)

     

       23
       -
       	mac := hmac.New(sha256.New, []byte(s.Secret))

     

       24
       -
       	message := req.Method + req.URL.Path + timestamp

     

       25
       -
       	mac.Write([]byte(message))

     

       26
       -
       	signature := hex.EncodeToString(mac.Sum(nil))

     

       27
       -
       	req.Header.Set("X-Signature", signature)

     

       28
       -
       	req.Header.Set("X-Timestamp", timestamp)

     

       29
       -
       	return http.DefaultTransport.RoundTrip(req)

     

       30
       -
       }

     

       31
       -
       

     

       32
       -
       type SignedClient struct {

     

       33
       -
       	Secret string

     

       34
       -
       	Url    *url.URL

     

       35
       -
       	client *http.Client

     

       36
       -
       }

     

       37
       -
       

     

       38
       -
       func NewSignedClient(domain, secret string, dev bool) (*SignedClient, error) {

     

       39
       -
       	client := &http.Client{

     

       40
       -
       		Timeout: 5 * time.Second,

     

       41
       -
       		Transport: SignerTransport{

     

       42
       -
       			Secret: secret,

     

       43
       -
       		},

     

       44
       -
       	}

     

       45
       -
       

     

       46
       -
       	scheme := "https"

     

       47
       -
       	if dev {

     

       48
       -
       		scheme = "http"

     

       49
       -
       	}

     

       50
       -
       	url, err := url.Parse(fmt.Sprintf("%s://%s", scheme, domain))

     

       51
       -
       	if err != nil {

     

       52
       -
       		return nil, err

     

       53
       -
       	}

     

       54
       -
       

     

       55
       -
       	signedClient := &SignedClient{

     

       56
       -
       		Secret: secret,

     

       57
       -
       		client: client,

     

       58
       -
       		Url:    url,

     

       59
       -
       	}

     

       60
       -
       

     

       61
       -
       	return signedClient, nil

     

       62
       -
       }

     

       63
       -
       

     

       64
       -
       func (s *SignedClient) newRequest(method, endpoint string, body []byte) (*http.Request, error) {

     

       65
       -
       	return http.NewRequest(method, s.Url.JoinPath(endpoint).String(), bytes.NewReader(body))

     

       66
       -
       }

     

       67
       -
       

     

       68
       -
       func (s *SignedClient) Init(did string) (*http.Response, error) {

     

       69
       -
       	const (

     

       70
       -
       		Method   = "POST"

     

       71
       -
       		Endpoint = "/init"

     

       72
       -
       	)

     

       73
       -
       

     

       74
       -
       	body, _ := json.Marshal(map[string]any{

     

       75
       -
       		"did": did,

     

       76
       -
       	})

     

       77
       -
       

     

       78
       -
       	req, err := s.newRequest(Method, Endpoint, body)

     

       79
       -
       	if err != nil {

     

       80
       -
       		return nil, err

     

       81
       -
       	}

     

       82
       -
       

     

       83
       -
       	return s.client.Do(req)

     

       84
       -
       }

     

       85
       -
       

     

       86
       -
       func (s *SignedClient) NewRepo(did, repoName, defaultBranch string) (*http.Response, error) {

     

       87
       -
       	const (

     

       88
       -
       		Method   = "PUT"

     

       89
       -
       		Endpoint = "/repo/new"

     

       90
       -
       	)

     

       91
       -
       

     

       92
       -
       	body, _ := json.Marshal(map[string]any{

     

       93
       -
       		"did":            did,

     

       94
       -
       		"name":           repoName,

     

       95
       -
       		"default_branch": defaultBranch,

     

       96
       -
       	})

     

       97
       -
       

     

       98
       -
       	req, err := s.newRequest(Method, Endpoint, body)

     

       99
       -
       	if err != nil {

     

       100
       -
       		return nil, err

     

       101
       -
       	}

     

       102
       -
       

     

       103
       -
       	return s.client.Do(req)

     

       104
       -
       }

     

       105
       -
       

     

       106
       -
       func (s *SignedClient) RepoForkAheadBehind(ownerDid, source, name, branch, hiddenRef string) (*http.Response, error) {

     

       107
       -
       	const (

     

       108
       -
       		Method = "GET"

     

       109
       -
       	)

     

       110
       -
       	endpoint := fmt.Sprintf("/repo/fork/sync/%s", url.PathEscape(branch))

     

       111
       -
       

     

       112
       -
       	body, _ := json.Marshal(map[string]any{

     

       113
       -
       		"did":       ownerDid,

     

       114
       -
       		"source":    source,

     

       115
       -
       		"name":      name,

     

       116
       -
       		"hiddenref": hiddenRef,

     

       117
       -
       	})

     

       118
       -
       

     

       119
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       120
       -
       	if err != nil {

     

       121
       -
       		return nil, err

     

       122
       -
       	}

     

       123
       -
       

     

       124
       -
       	return s.client.Do(req)

     

       125
       -
       }

     

       126
       -
       

     

       127
       -
       func (s *SignedClient) SyncRepoFork(ownerDid, source, name, branch string) (*http.Response, error) {

     

       128
       -
       	const (

     

       129
       -
       		Method = "POST"

     

       130
       -
       	)

     

       131
       -
       	endpoint := fmt.Sprintf("/repo/fork/sync/%s", url.PathEscape(branch))

     

       132
       -
       

     

       133
       -
       	body, _ := json.Marshal(map[string]any{

     

       134
       -
       		"did":    ownerDid,

     

       135
       -
       		"source": source,

     

       136
       -
       		"name":   name,

     

       137
       -
       	})

     

       138
       -
       

     

       139
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       140
       -
       	if err != nil {

     

       141
       -
       		return nil, err

     

       142
       -
       	}

     

       143
       -
       

     

       144
       -
       	return s.client.Do(req)

     

       145
       -
       }

     

       146
       -
       

     

       147
       -
       func (s *SignedClient) ForkRepo(ownerDid, source, name string) (*http.Response, error) {

     

       148
       -
       	const (

     

       149
       -
       		Method   = "POST"

     

       150
       -
       		Endpoint = "/repo/fork"

     

       151
       -
       	)

     

       152
       -
       

     

       153
       -
       	body, _ := json.Marshal(map[string]any{

     

       154
       -
       		"did":    ownerDid,

     

       155
       -
       		"source": source,

     

       156
       -
       		"name":   name,

     

       157
       -
       	})

     

       158
       -
       

     

       159
       -
       	req, err := s.newRequest(Method, Endpoint, body)

     

       160
       -
       	if err != nil {

     

       161
       -
       		return nil, err

     

       162
       -
       	}

     

       163
       -
       

     

       164
       -
       	return s.client.Do(req)

     

       165
       -
       }

     

       166
       -
       

     

       167
       -
       func (s *SignedClient) RemoveRepo(did, repoName string) (*http.Response, error) {

     

       168
       -
       	const (

     

       169
       -
       		Method   = "DELETE"

     

       170
       -
       		Endpoint = "/repo"

     

       171
       -
       	)

     

       172
       -
       

     

       173
       -
       	body, _ := json.Marshal(map[string]any{

     

       174
       -
       		"did":  did,

     

       175
       -
       		"name": repoName,

     

       176
       -
       	})

     

       177
       -
       

     

       178
       -
       	req, err := s.newRequest(Method, Endpoint, body)

     

       179
       -
       	if err != nil {

     

       180
       -
       		return nil, err

     

       181
       -
       	}

     

       182
       -
       

     

       183
       -
       	return s.client.Do(req)

     

       184
       -
       }

     

       185
       -
       

     

       186
       -
       func (s *SignedClient) AddMember(did string) (*http.Response, error) {

     

       187
       -
       	const (

     

       188
       -
       		Method   = "PUT"

     

       189
       -
       		Endpoint = "/member/add"

     

       190
       -
       	)

     

       191
       -
       

     

       192
       -
       	body, _ := json.Marshal(map[string]any{

     

       193
       -
       		"did": did,

     

       194
       -
       	})

     

       195
       -
       

     

       196
       -
       	req, err := s.newRequest(Method, Endpoint, body)

     

       197
       -
       	if err != nil {

     

       198
       -
       		return nil, err

     

       199
       -
       	}

     

       200
       -
       

     

       201
       -
       	return s.client.Do(req)

     

       202
       -
       }

     

       203
       -
       

     

       204
       -
       func (s *SignedClient) SetDefaultBranch(ownerDid, repoName, branch string) (*http.Response, error) {

     

       205
       -
       	const (

     

       206
       -
       		Method = "PUT"

     

       207
       -
       	)

     

       208
       -
       	endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName)

     

       209
       -
       

     

       210
       -
       	body, _ := json.Marshal(map[string]any{

     

       211
       -
       		"branch": branch,

     

       212
       -
       	})

     

       213
       -
       

     

       214
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       215
       -
       	if err != nil {

     

       216
       -
       		return nil, err

     

       217
       -
       	}

     

       218
       -
       

     

       219
       -
       	return s.client.Do(req)

     

       220
       -
       }

     

       221
       -
       

     

       222
       -
       func (s *SignedClient) AddCollaborator(ownerDid, repoName, memberDid string) (*http.Response, error) {

     

       223
       -
       	const (

     

       224
       -
       		Method = "POST"

     

       225
       -
       	)

     

       226
       -
       	endpoint := fmt.Sprintf("/%s/%s/collaborator/add", ownerDid, repoName)

     

       227
       -
       

     

       228
       -
       	body, _ := json.Marshal(map[string]any{

     

       229
       -
       		"did": memberDid,

     

       230
       -
       	})

     

       231
       -
       

     

       232
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       233
       -
       	if err != nil {

     

       234
       -
       		return nil, err

     

       235
       -
       	}

     

       236
       -
       

     

       237
       -
       	return s.client.Do(req)

     

       238
       -
       }

     

       239
       -
       

     

       240
       -
       func (s *SignedClient) Merge(

     

       241
       -
       	patch []byte,

     

       242
       -
       	ownerDid, targetRepo, branch, commitMessage, commitBody, authorName, authorEmail string,

     

       243
       -
       ) (*http.Response, error) {

     

       244
       -
       	const (

     

       245
       -
       		Method = "POST"

     

       246
       -
       	)

     

       247
       -
       	endpoint := fmt.Sprintf("/%s/%s/merge", ownerDid, targetRepo)

     

       248
       -
       

     

       249
       -
       	mr := types.MergeRequest{

     

       250
       -
       		Branch:        branch,

     

       251
       -
       		CommitMessage: commitMessage,

     

       252
       -
       		CommitBody:    commitBody,

     

       253
       -
       		AuthorName:    authorName,

     

       254
       -
       		AuthorEmail:   authorEmail,

     

       255
       -
       		Patch:         string(patch),

     

       256
       -
       	}

     

       257
       -
       

     

       258
       -
       	body, _ := json.Marshal(mr)

     

       259
       -
       

     

       260
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       261
       -
       	if err != nil {

     

       262
       -
       		return nil, err

     

       263
       -
       	}

     

       264
       -
       

     

       265
       -
       	return s.client.Do(req)

     

       266
       -
       }

     

       267
       -
       

     

       268
       -
       func (s *SignedClient) MergeCheck(patch []byte, ownerDid, targetRepo, branch string) (*http.Response, error) {

     

       269
       -
       	const (

     

       270
       -
       		Method = "POST"

     

       271
       -
       	)

     

       272
       -
       	endpoint := fmt.Sprintf("/%s/%s/merge/check", ownerDid, targetRepo)

     

       273
       -
       

     

       274
       -
       	body, _ := json.Marshal(map[string]any{

     

       275
       -
       		"patch":  string(patch),

     

       276
       -
       		"branch": branch,

     

       277
       -
       	})

     

       278
       -
       

     

       279
       -
       	req, err := s.newRequest(Method, endpoint, body)

     

       280
       -
       	if err != nil {

     

       281
       -
       		return nil, err

     

       282
       -
       	}

     

       283
       -
       

     

       284
       -
       	return s.client.Do(req)

     

       285
       -
       }

     

       286
       -
       

     

       287
       -
       func (s *SignedClient) NewHiddenRef(ownerDid, targetRepo, forkBranch, remoteBranch string) (*http.Response, error) {

     

       288
       -
       	const (

     

       289
       -
       		Method = "POST"

     

       290
       -
       	)

     

       291
       -
       	endpoint := fmt.Sprintf("/%s/%s/hidden-ref/%s/%s", ownerDid, targetRepo, url.PathEscape(forkBranch), url.PathEscape(remoteBranch))

     

       292
       -
       

     

       293
       -
       	req, err := s.newRequest(Method, endpoint, nil)

     

       294
       -
       	if err != nil {

     

       295
       -
       		return nil, err

     

       296
       -
       	}

     

       297
       -
       

     

       298
       -
       	return s.client.Do(req)

     

       299
       -
       }

-7

nix/modules/knot.nix

···

       99
        
                   description = "DID of owner (required)";

     

       100
        
                 };

     

       101
        
       

     

       102
       -
                 secretFile = mkOption {

     

       103
       -
                   type = lib.types.path;

     

       104
       -
                   example = "KNOT_SERVER_SECRET=<hash>";

     

       105
       -
                   description = "File containing secret key provided by appview (required)";

     

       106
       -
                 };

     

       107
       -
       

     

       108
        
                 dbPath = mkOption {

     

       109
        
                   type = types.path;

     

       110
        
                   default = "${cfg.stateDir}/knotserver.db";

     
···

       207
        
                   "KNOT_SERVER_HOSTNAME=${cfg.server.hostname}"

     

       208
        
                   "KNOT_SERVER_OWNER=${cfg.server.owner}"

     

       209
        
                 ];

     

       210
       -
                 EnvironmentFile = cfg.server.secretFile;

     

       211
        
                 ExecStart = "${cfg.package}/bin/knot server";

     

       212
        
                 Restart = "always";

     

       213
        
               };

···

       99
        
                   description = "DID of owner (required)";

     

       100
        
                 };

     

       101
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       102
        
                 dbPath = mkOption {

     

       103
        
                   type = types.path;

     

       104
        
                   default = "${cfg.stateDir}/knotserver.db";

     
···

       201
        
                   "KNOT_SERVER_HOSTNAME=${cfg.server.hostname}"

     

       202
        
                   "KNOT_SERVER_OWNER=${cfg.server.owner}"

     

       203
        
                 ];

     

       0
        
       
     

       204
        
                 ExecStart = "${cfg.package}/bin/knot server";

     

       205
        
                 Restart = "always";

     

       206
        
               };

+2 -2

rbac/rbac.go

···

       281
        
       	return e.E.Enforce(user, domain, domain, "repo:create")

     

       282
        
       }

     

       283
        
       

     

       284
       -
       func (e *Enforcer) IsRepoDeleteAllowed(user, domain string) (bool, error) {

     

       285
       -
       	return e.E.Enforce(user, domain, domain, "repo:delete")

     

       286
        
       }

     

       287
        
       

     

       288
        
       func (e *Enforcer) IsPushAllowed(user, domain, repo string) (bool, error) {

···

       281
        
       	return e.E.Enforce(user, domain, domain, "repo:create")

     

       282
        
       }

     

       283
        
       

     

       284
       +
       func (e *Enforcer) IsRepoDeleteAllowed(user, domain, repo string) (bool, error) {

     

       285
       +
       	return e.E.Enforce(user, domain, repo, "repo:delete")

     

       286
        
       }

     

       287
        
       

     

       288
        
       func (e *Enforcer) IsPushAllowed(user, domain, repo string) (bool, error) {

+4 -7

api/tangled/pullcomment.go

···

       17
        
       } //

     

       18
        
       // RECORDTYPE: RepoPullComment

     

       19
        
       type RepoPullComment struct {

     

       20
       -
       	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.pull.comment" cborgen:"$type,const=sh.tangled.repo.pull.comment"`

     

       21
       -
       	Body          string  `json:"body" cborgen:"body"`

     

       22
       -
       	CommentId     *int64  `json:"commentId,omitempty" cborgen:"commentId,omitempty"`

     

       23
       -
       	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       24
       -
       	Owner         *string `json:"owner,omitempty" cborgen:"owner,omitempty"`

     

       25
       -
       	Pull          string  `json:"pull" cborgen:"pull"`

     

       26
       -
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

     

       27
        
       }

···

       17
        
       } //

     

       18
        
       // RECORDTYPE: RepoPullComment

     

       19
        
       type RepoPullComment struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull.comment" cborgen:"$type,const=sh.tangled.repo.pull.comment"`

     

       21
       +
       	Body          string `json:"body" cborgen:"body"`

     

       22
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       23
       +
       	Pull          string `json:"pull" cborgen:"pull"`

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
       }

-11

lexicons/pulls/comment.json

···

       19
        
                   "type": "string",

     

       20
        
                   "format": "at-uri"

     

       21
        
                 },

     

       22
       -
                 "repo": {

     

       23
       -
                   "type": "string",

     

       24
       -
                   "format": "at-uri"

     

       25
       -
                 },

     

       26
       -
                 "commentId": {

     

       27
       -
                   "type": "integer"

     

       28
       -
                 },

     

       29
       -
                 "owner": {

     

       30
       -
                   "type": "string",

     

       31
       -
                   "format": "did"

     

       32
       -
                 },

     

       33
        
                 "body": {

     

       34
        
                   "type": "string"

     

       35
        
                 },

···

       19
        
                   "type": "string",

     

       20
        
                   "format": "at-uri"

     

       21
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
                 "body": {

     

       23
        
                   "type": "string"

     

       24
        
                 },

+7 -2

api/tangled/repopull.go

···

       22
        
       	CreatedAt     string           `json:"createdAt" cborgen:"createdAt"`

     

       23
        
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
        
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       -
       	TargetBranch  string           `json:"targetBranch" cborgen:"targetBranch"`

     

       26
       -
       	TargetRepo    string           `json:"targetRepo" cborgen:"targetRepo"`

     

       27
        
       	Title         string           `json:"title" cborgen:"title"`

     

       28
        
       }

     

       29
        
       

     
···

       33
        
       	Repo   *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

     

       34
        
       	Sha    string  `json:"sha" cborgen:"sha"`

     

       35
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       22
        
       	CreatedAt     string           `json:"createdAt" cborgen:"createdAt"`

     

       23
        
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
        
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       +
       	Target        *RepoPull_Target `json:"target" cborgen:"target"`

     

       0
        
       
     

       26
        
       	Title         string           `json:"title" cborgen:"title"`

     

       27
        
       }

     

       28
        
       

     
···

       32
        
       	Repo   *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

     

       33
        
       	Sha    string  `json:"sha" cborgen:"sha"`

     

       34
        
       }

     

       35
       +
       

     

       36
       +
       // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.

     

       37
       +
       type RepoPull_Target struct {

     

       38
       +
       	Branch string `json:"branch" cborgen:"branch"`

     

       39
       +
       	Repo   string `json:"repo" cborgen:"repo"`

     

       40
       +
       }

+20 -8

lexicons/pulls/pull.json

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       -
                 "targetRepo",

     

       14
       -
                 "targetBranch",

     

       15
        
                 "title",

     

       16
        
                 "patch",

     

       17
        
                 "createdAt"

     

       18
        
               ],

     

       19
        
               "properties": {

     

       20
       -
                 "targetRepo": {

     

       21
       -
                   "type": "string",

     

       22
       -
                   "format": "at-uri"

     

       23
       -
                 },

     

       24
       -
                 "targetBranch": {

     

       25
       -
                   "type": "string"

     

       26
        
                 },

     

       27
        
                 "title": {

     

       28
        
                   "type": "string"

     
···

       44
        
               }

     

       45
        
             }

     

       46
        
           },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
           "source": {

     

       48
        
             "type": "object",

     

       49
        
             "required": [

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       +
                 "target",

     

       0
        
       
     

       14
        
                 "title",

     

       15
        
                 "patch",

     

       16
        
                 "createdAt"

     

       17
        
               ],

     

       18
        
               "properties": {

     

       19
       +
                 "target": {

     

       20
       +
                   "type": "ref",

     

       21
       +
                   "ref": "#target"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
                 },

     

       23
        
                 "title": {

     

       24
        
                   "type": "string"

     
···

       40
        
               }

     

       41
        
             }

     

       42
        
           },

     

       43
       +
           "target": {

     

       44
       +
             "type": "object",

     

       45
       +
             "required": [

     

       46
       +
               "repo",

     

       47
       +
               "branch"

     

       48
       +
             ],

     

       49
       +
             "properties": {

     

       50
       +
               "repo": {

     

       51
       +
                 "type": "string",

     

       52
       +
                 "format": "at-uri"

     

       53
       +
               },

     

       54
       +
               "branch": {

     

       55
       +
                 "type": "string"

     

       56
       +
               }

     

       57
       +
             }

     

       58
       +
           },

     

       59
        
           "source": {

     

       60
        
             "type": "object",

     

       61
        
             "required": [

+2 -2

appview/pages/templates/repo/pulls/fragments/pullCompareForks.html

···

       19
        
                       >

     

       20
        
                           <option disabled selected>select a fork</option>

     

       21
        
                           {{ range .Forks }}

     

       22
       -
                               <option value="{{ .Name }}" {{ if eq .Name $.Selected }}selected{{ end }} class="py-1">

     

       23
       -
                                   {{ .Name }}

     

       24
        
                               </option>

     

       25
        
                           {{ end }}

     

       26
        
                       </select>

···

       19
        
                       >

     

       20
        
                           <option disabled selected>select a fork</option>

     

       21
        
                           {{ range .Forks }}

     

       22
       +
                               <option value="{{ .Did }}/{{ .Name }}" {{ if eq .Name $.Selected }}selected{{ end }} class="py-1">

     

       23
       +
                                   {{ .Did | resolve }}/{{ .Name }}

     

       24
        
                               </option>

     

       25
        
                           {{ end }}

     

       26
        
                       </select>

+17

appview/pages/markup/sanitizer.go

···

       97
        
       		"margin-bottom",

     

       98
        
       	)

     

       99
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       100
        
       	return policy

     

       101
        
       }

     

       102

···

       97
        
       		"margin-bottom",

     

       98
        
       	)

     

       99
        
       

     

       100
       +
       	// math

     

       101
       +
       	mathAttrs := []string{

     

       102
       +
       		"accent", "columnalign", "columnlines", "columnspan", "dir", "display",

     

       103
       +
       		"displaystyle", "encoding", "fence", "form", "largeop", "linebreak",

     

       104
       +
       		"linethickness", "lspace", "mathcolor", "mathsize", "mathvariant", "minsize",

     

       105
       +
       		"movablelimits", "notation", "rowalign", "rspace", "rowspacing", "rowspan",

     

       106
       +
       		"scriptlevel", "stretchy", "symmetric", "title", "voffset", "width",

     

       107
       +
       	}

     

       108
       +
       	mathElements := []string{

     

       109
       +
       		"annotation", "math", "menclose", "merror", "mfrac", "mi", "mmultiscripts",

     

       110
       +
       		"mn", "mo", "mover", "mpadded", "mprescripts", "mroot", "mrow", "mspace",

     

       111
       +
       		"msqrt", "mstyle", "msub", "msubsup", "msup", "mtable", "mtd", "mtext",

     

       112
       +
       		"mtr", "munder", "munderover", "semantics",

     

       113
       +
       	}

     

       114
       +
       	policy.AllowNoAttrs().OnElements(mathElements...)

     

       115
       +
       	policy.AllowAttrs(mathAttrs...).OnElements(mathElements...)

     

       116
       +
       

     

       117
        
       	return policy

     

       118
        
       }

     

       119

+6 -1

go.sum

···

       426
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=

     

       427
        
       github.com/whyrusleeping/cbor-gen v0.3.1 h1:82ioxmhEYut7LBVGhGq8xoRkXPLElVuh5mV67AFfdv0=

     

       428
        
       github.com/whyrusleeping/cbor-gen v0.3.1/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       429
        
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       430
        
       github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       431
        
       github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

     

       432
        
       github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

     

       433
        
       github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

     

       434
       -
       github.com/yuin/goldmark v1.4.15 h1:CFa84T0goNn/UIXYS+dmjjVxMyTAvpOmzld40N/nfK0=

     

       435
        
       github.com/yuin/goldmark v1.4.15/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

     

       0
        
       
     

       0
        
       
     

       436
        
       github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc h1:+IAOyRda+RLrxa1WC7umKOZRsGq4QrFFMYApOeHzQwQ=

     

       437
        
       github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc/go.mod h1:ovIvrum6DQJA4QsJSovrkC4saKHQVs7TvcaeO8AIl5I=

     

       438
        
       gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA=

···

       426
        
       github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=

     

       427
        
       github.com/whyrusleeping/cbor-gen v0.3.1 h1:82ioxmhEYut7LBVGhGq8xoRkXPLElVuh5mV67AFfdv0=

     

       428
        
       github.com/whyrusleeping/cbor-gen v0.3.1/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=

     

       429
       +
       github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57 h1:UqtQdzLXnvdBdqn/go53qGyncw1wJ7Mq5SQdieM1/Ew=

     

       430
       +
       github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57/go.mod h1:BxSCWByWSRSuembL3cDG1IBUbkBoO/oW/6tF19aA4hs=

     

       431
       +
       github.com/wyatt915/treeblood v0.1.15 h1:3KZ3o2LpcKZAzOLqMoW9qeUzKEaKArKpbcPpTkNfQC8=

     

       432
       +
       github.com/wyatt915/treeblood v0.1.15/go.mod h1:i7+yhhmzdDP17/97pIsOSffw74EK/xk+qJ0029cSXUY=

     

       433
        
       github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       434
        
       github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

     

       435
        
       github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

     

       436
        
       github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

     

       437
        
       github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

     

       0
        
       
     

       438
        
       github.com/yuin/goldmark v1.4.15/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=

     

       439
       +
       github.com/yuin/goldmark v1.7.12 h1:YwGP/rrea2/CnCtUHgjuolG/PnMxdQtPMO5PvaE2/nY=

     

       440
       +
       github.com/yuin/goldmark v1.7.12/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=

     

       441
        
       github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc h1:+IAOyRda+RLrxa1WC7umKOZRsGq4QrFFMYApOeHzQwQ=

     

       442
        
       github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc/go.mod h1:ovIvrum6DQJA4QsJSovrkC4saKHQVs7TvcaeO8AIl5I=

     

       443
        
       gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA=

-2

api/tangled/repoissue.go

···

       20
        
       	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"`

     

       21
        
       	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
        
       	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       23
       -
       	IssueId       int64   `json:"issueId" cborgen:"issueId"`

     

       24
       -
       	Owner         string  `json:"owner" cborgen:"owner"`

     

       25
        
       	Repo          string  `json:"repo" cborgen:"repo"`

     

       26
        
       	Title         string  `json:"title" cborgen:"title"`

     

       27
        
       }

···

       20
        
       	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"`

     

       21
        
       	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       22
        
       	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       0
        
       
     

       0
        
       
     

       23
        
       	Repo          string  `json:"repo" cborgen:"repo"`

     

       24
        
       	Title         string  `json:"title" cborgen:"title"`

     

       25
        
       }

+1 -14

lexicons/issue/issue.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": [

     

       13
       -
                 "repo",

     

       14
       -
                 "issueId",

     

       15
       -
                 "owner",

     

       16
       -
                 "title",

     

       17
       -
                 "createdAt"

     

       18
       -
               ],

     

       19
        
               "properties": {

     

       20
        
                 "repo": {

     

       21
        
                   "type": "string",

     

       22
        
                   "format": "at-uri"

     

       23
        
                 },

     

       24
       -
                 "issueId": {

     

       25
       -
                   "type": "integer"

     

       26
       -
                 },

     

       27
       -
                 "owner": {

     

       28
       -
                   "type": "string",

     

       29
       -
                   "format": "did"

     

       30
       -
                 },

     

       31
        
                 "title": {

     

       32
        
                   "type": "string"

     

       33
        
                 },

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": ["repo", "title", "createdAt"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "repo": {

     

       15
        
                   "type": "string",

     

       16
        
                   "format": "at-uri"

     

       17
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
                 "title": {

     

       19
        
                   "type": "string"

     

       20
        
                 },

+16

nix/modules/spindle.nix

···

       55
        
                   description = "DID of owner (required)";

     

       56
        
                 };

     

       57
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       58
        
                 secrets = {

     

       59
        
                   provider = mkOption {

     

       60
        
                     type = types.str;

     
···

       108
        
                   "SPINDLE_SERVER_JETSTREAM=${cfg.server.jetstreamEndpoint}"

     

       109
        
                   "SPINDLE_SERVER_DEV=${lib.boolToString cfg.server.dev}"

     

       110
        
                   "SPINDLE_SERVER_OWNER=${cfg.server.owner}"

     

       0
        
       
     

       0
        
       
     

       111
        
                   "SPINDLE_SERVER_SECRETS_PROVIDER=${cfg.server.secrets.provider}"

     

       112
        
                   "SPINDLE_SERVER_SECRETS_OPENBAO_PROXY_ADDR=${cfg.server.secrets.openbao.proxyAddr}"

     

       113
        
                   "SPINDLE_SERVER_SECRETS_OPENBAO_MOUNT=${cfg.server.secrets.openbao.mount}"

···

       55
        
                   description = "DID of owner (required)";

     

       56
        
                 };

     

       57
        
       

     

       58
       +
                 maxJobCount = mkOption {

     

       59
       +
                   type = types.int;

     

       60
       +
                   default = 2;

     

       61
       +
                   example = 5;

     

       62
       +
                   description = "Maximum number of concurrent jobs to run";

     

       63
       +
                 };

     

       64
       +
       

     

       65
       +
                 queueSize = mkOption {

     

       66
       +
                   type = types.int;

     

       67
       +
                   default = 100;

     

       68
       +
                   example = 100;

     

       69
       +
                   description = "Maximum number of jobs queue up";

     

       70
       +
                 };

     

       71
       +
       

     

       72
        
                 secrets = {

     

       73
        
                   provider = mkOption {

     

       74
        
                     type = types.str;

     
···

       122
        
                   "SPINDLE_SERVER_JETSTREAM=${cfg.server.jetstreamEndpoint}"

     

       123
        
                   "SPINDLE_SERVER_DEV=${lib.boolToString cfg.server.dev}"

     

       124
        
                   "SPINDLE_SERVER_OWNER=${cfg.server.owner}"

     

       125
       +
                   "SPINDLE_SERVER_MAX_JOB_COUNT=${toString cfg.server.maxJobCount}"

     

       126
       +
                   "SPINDLE_SERVER_QUEUE_SIZE=${toString cfg.server.queueSize}"

     

       127
        
                   "SPINDLE_SERVER_SECRETS_PROVIDER=${cfg.server.secrets.provider}"

     

       128
        
                   "SPINDLE_SERVER_SECRETS_OPENBAO_PROXY_ADDR=${cfg.server.secrets.openbao.proxyAddr}"

     

       129
        
                   "SPINDLE_SERVER_SECRETS_OPENBAO_MOUNT=${cfg.server.secrets.openbao.mount}"

+2 -2

appview/pages/templates/repo/compare/compare.html

···

       12
        
       

     

       13
        
       {{ define "topbarLayout" }}

     

       14
        
         <header class="px-1 col-span-full" style="z-index: 20;">

     

       15
       -
           {{ template "layouts/topbar" . }}

     

       16
        
         </header>

     

       17
        
       {{ end }}

     

       18
        
       

     
···

       37
        
       

     

       38
        
       {{ define "footerLayout" }}

     

       39
        
         <footer class="px-1 col-span-full mt-12">

     

       40
       -
           {{ template "layouts/footer" . }}

     

       41
        
         </footer>

     

       42
        
       {{ end }}

     

       43

···

       12
        
       

     

       13
        
       {{ define "topbarLayout" }}

     

       14
        
         <header class="px-1 col-span-full" style="z-index: 20;">

     

       15
       +
           {{ template "layouts/fragments/topbar" . }}

     

       16
        
         </header>

     

       17
        
       {{ end }}

     

       18
        
       

     
···

       37
        
       

     

       38
        
       {{ define "footerLayout" }}

     

       39
        
         <footer class="px-1 col-span-full mt-12">

     

       40
       +
           {{ template "layouts/fragments/footer" . }}

     

       41
        
         </footer>

     

       42
        
       {{ end }}

     

       43

appview/pages/templates/repo/fragments/duration.html

···

       1
       +
       {{ define "repo/fragments/duration" }}

     

       2
       +
       <time datetime="{{ . | iso8601DurationFmt }}" title="{{ . | longDurationFmt }}">{{ . | durationFmt }}</time>

     

       3
       +
       {{ end }}

     

       4
       +

appview/pages/templates/repo/fragments/shortTime.html

···

       1
       +
       {{ define "repo/fragments/shortTime" }}

     

       2
       +
       {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (. | shortRelTimeFmt)) }}

     

       3
       +
       {{ end }}

     

       4
       +

-16

appview/pages/templates/repo/fragments/time.html

···

       1
       -
       {{ define "repo/fragments/timeWrapper" }}

     

       2
       -
       <time datetime="{{ .Time | iso8601DateTimeFmt }}" title="{{ .Time | longTimeFmt }}">{{ .Content }}</time>

     

       3
       -
       {{ end }}

     

       4
       -
       

     

       5
        
       {{ define "repo/fragments/time" }}

     

       6
        
       {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (. | relTimeFmt)) }}

     

       7
        
       {{ end }}

     

       8
       -
       

     

       9
       -
       {{ define "repo/fragments/shortTime" }}

     

       10
       -
       {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (. | shortRelTimeFmt)) }}

     

       11
       -
       {{ end }}

     

       12
       -
       

     

       13
       -
       {{ define "repo/fragments/shortTimeAgo" }}

     

       14
       -
       {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (print (. | shortRelTimeFmt) " ago")) }}

     

       15
       -
       {{ end }}

     

       16
       -
       

     

       17
       -
       {{ define "repo/fragments/duration" }}

     

       18
       -
       <time datetime="{{ . | iso8601DurationFmt }}" title="{{ . | longDurationFmt }}">{{ . | durationFmt }}</time>

     

       19
       -
       {{ end }}

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       {{ define "repo/fragments/time" }}

     

       2
        
       {{ template "repo/fragments/timeWrapper" (dict "Time" . "Content" (. | relTimeFmt)) }}

     

       3
        
       {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

appview/pages/templates/repo/fragments/timeWrapper.html

···

       1
       +
       {{ define "repo/fragments/timeWrapper" }}

     

       2
       +
       <time datetime="{{ .Time | iso8601DateTimeFmt }}" title="{{ .Time | longTimeFmt }}">{{ .Content }}</time>

     

       3
       +
       {{ end }}

     

       4
       +
       

     

       5
       +

+1 -1

appview/pages/templates/repo/pulls/fragments/pullStack.html

···

       52
        
                   </div>

     

       53
        
                 {{ end }}

     

       54
        
                 <div class="{{ if not $isCurrent }} pl-6 {{ end }} flex-grow min-w-0 w-full py-2">

     

       55
       -
                   {{ template "repo/pulls/fragments/summarizedHeader" (list $pull $pipeline) }}

     

       56
        
                 </div>

     

       57
        
               </div>

     

       58
        
             </a>

···

       52
        
                   </div>

     

       53
        
                 {{ end }}

     

       54
        
                 <div class="{{ if not $isCurrent }} pl-6 {{ end }} flex-grow min-w-0 w-full py-2">

     

       55
       +
                   {{ template "repo/pulls/fragments/summarizedPullHeader" (list $pull $pipeline) }}

     

       56
        
                 </div>

     

       57
        
               </div>

     

       58
        
             </a>

+35

appview/pages/cache.go

···

       1
       +
       package pages

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"sync"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type TmplCache[K comparable, V any] struct {

     

       8
       +
       	data  map[K]V

     

       9
       +
       	mutex sync.RWMutex

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       func NewTmplCache[K comparable, V any]() *TmplCache[K, V] {

     

       13
       +
       	return &TmplCache[K, V]{

     

       14
       +
       		data: make(map[K]V),

     

       15
       +
       	}

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       func (c *TmplCache[K, V]) Get(key K) (V, bool) {

     

       19
       +
       	c.mutex.RLock()

     

       20
       +
       	defer c.mutex.RUnlock()

     

       21
       +
       	val, exists := c.data[key]

     

       22
       +
       	return val, exists

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       func (c *TmplCache[K, V]) Set(key K, value V) {

     

       26
       +
       	c.mutex.Lock()

     

       27
       +
       	defer c.mutex.Unlock()

     

       28
       +
       	c.data[key] = value

     

       29
       +
       }

     

       30
       +
       

     

       31
       +
       func (c *TmplCache[K, V]) Size() int {

     

       32
       +
       	c.mutex.RLock()

     

       33
       +
       	defer c.mutex.RUnlock()

     

       34
       +
       	return len(c.data)

     

       35
       +
       }

+1 -1

appview/pages/templates/user/fragments/editBio.html

···

       13
        
             <label class="m-0 p-0" for="description">bio</label>

     

       14
        
             <textarea 

     

       15
        
               type="text" 

     

       16
       -
               class="py-1 px-1 w-full" 

     

       17
        
               name="description" 

     

       18
        
               rows="3"

     

       19
        
               placeholder="write a bio">{{ $description }}</textarea>

···

       13
        
             <label class="m-0 p-0" for="description">bio</label>

     

       14
        
             <textarea 

     

       15
        
               type="text" 

     

       16
       +
               class="p-2 w-full" 

     

       17
        
               name="description" 

     

       18
        
               rows="3"

     

       19
        
               placeholder="write a bio">{{ $description }}</textarea>

+19

appview/pages/templates/user/starred.html

···

       1
       +
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · repos {{ end }}

     

       2
       +
       

     

       3
       +
       {{ define "profileContent" }}

     

       4
       +
         <div id="all-repos" class="md:col-span-8 order-2 md:order-2">

     

       5
       +
             {{ block "starredRepos" . }}{{ end }}

     

       6
       +
         </div>

     

       7
       +
       {{ end }}

     

       8
       +
       

     

       9
       +
       {{ define "starredRepos" }}

     

       10
       +
         <div id="repos" class="grid grid-cols-1 gap-4 mb-6">

     

       11
       +
           {{ range .Repos }}

     

       12
       +
             <div class="border border-gray-200 dark:border-gray-700 rounded-sm">

     

       13
       +
                {{ template "user/fragments/repoCard" (list $ . true) }}

     

       14
       +
             </div>

     

       15
       +
           {{ else }}

     

       16
       +
               <p class="px-6 dark:text-white">This user does not have any starred repos yet.</p>

     

       17
       +
           {{ end }}

     

       18
       +
         </div>

     

       19
       +
       {{ end }}

+2 -2

appview/pages/templates/user/fragments/profileCard.html

···

       92
        
         {{ with $root }}

     

       93
        
           <div class="flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm">

     

       94
        
             <span class="flex-shrink-0">{{ i "users" "size-4" }}</span>

     

       95
       -
             <span id="followers"><a href="/{{ $userIdent }}?tab=followers">{{ .FollowersCount }} followers</a></span>

     

       96
        
             <span class="select-none after:content-['·']"></span>

     

       97
       -
             <span id="following"><a href="/{{ $userIdent }}?tab=following">{{ .FollowingCount }} following</a></span>

     

       98
        
           </div>

     

       99
        
         {{ end }}

     

       100
        
       {{ end }}

···

       92
        
         {{ with $root }}

     

       93
        
           <div class="flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm">

     

       94
        
             <span class="flex-shrink-0">{{ i "users" "size-4" }}</span>

     

       95
       +
             <span id="followers"><a href="/{{ $userIdent }}?tab=followers">{{ .Stats.FollowersCount }} followers</a></span>

     

       96
        
             <span class="select-none after:content-['·']"></span>

     

       97
       +
             <span id="following"><a href="/{{ $userIdent }}?tab=following">{{ .Stats.FollowingCount }} following</a></span>

     

       98
        
           </div>

     

       99
        
         {{ end }}

     

       100
        
       {{ end }}

+45

appview/pages/templates/user/strings.html

···

       1
       +
       {{ define "title" }}{{ or .Card.UserHandle .Card.UserDid }} · strings {{ end }}

     

       2
       +
       

     

       3
       +
       {{ define "profileContent" }}

     

       4
       +
         <div id="all-strings" class="md:col-span-8 order-2 md:order-2">

     

       5
       +
           {{ block "allStrings" . }}{{ end }}

     

       6
       +
         </div>

     

       7
       +
       {{ end }}

     

       8
       +
       

     

       9
       +
       {{ define "allStrings" }}

     

       10
       +
         <div id="strings" class="grid grid-cols-1 gap-4 mb-6">

     

       11
       +
           {{ range .Strings }}

     

       12
       +
             <div class="border border-gray-200 dark:border-gray-700 rounded-sm">

     

       13
       +
               {{ template "singleString" (list $ .) }}

     

       14
       +
             </div>

     

       15
       +
           {{ else }}

     

       16
       +
             <p class="px-6 dark:text-white">This user does not have any strings yet.</p>

     

       17
       +
           {{ end }}

     

       18
       +
         </div>

     

       19
       +
       {{ end }}

     

       20
       +
       

     

       21
       +
       {{ define "singleString" }}

     

       22
       +
         {{ $root := index . 0 }}

     

       23
       +
         {{ $s := index . 1 }}

     

       24
       +
         <div class="py-4 px-6 rounded bg-white dark:bg-gray-800">

     

       25
       +
           <div class="font-medium dark:text-white flex gap-2 items-center">

     

       26
       +
               <a href="/strings/{{ or $root.Card.UserHandle $root.Card.UserDid  }}/{{ $s.Rkey }}">{{ $s.Filename }}</a>

     

       27
       +
           </div>

     

       28
       +
           {{ with $s.Description }}

     

       29
       +
             <div class="text-gray-600 dark:text-gray-300 text-sm">

     

       30
       +
                 {{ . }}

     

       31
       +
             </div>

     

       32
       +
           {{ end }}

     

       33
       +
       

     

       34
       +
           {{ $stat := $s.Stats }}

     

       35
       +
           <div class="text-gray-400 pt-4 text-sm font-mono inline-flex gap-2 mt-auto">

     

       36
       +
             <span>{{ $stat.LineCount }} line{{if ne $stat.LineCount 1}}s{{end}}</span>

     

       37
       +
             <span class="select-none [&:before]:content-['·']"></span>

     

       38
       +
             {{ with $s.Edited }}

     

       39
       +
               <span>edited {{ template "repo/fragments/shortTimeAgo" . }}</span>

     

       40
       +
             {{ else }}

     

       41
       +
               {{ template "repo/fragments/shortTimeAgo" $s.Created }}

     

       42
       +
             {{ end }}

     

       43
       +
           </div>

     

       44
       +
         </div>

     

       45
       +
       {{ end }}

+22 -2

knotserver/routes.go

···

       156
        
       		}

     

       157
        
       

     

       158
        
       		var modVer string

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       159
        
       		for _, mod := range info.Deps {

     

       160
        
       			if mod.Path == "tangled.sh/tangled.sh/knotserver" {

     

       161
       -
       				version = mod.Version

     

       162
        
       				break

     

       163
        
       			}

     

       164
        
       		}

     

       165
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       166
        
       		if modVer == "" {

     

       167
       -
       			version = "unknown"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       168
        
       		}

     

       169
        
       	}

     

       170

···

       156
        
       		}

     

       157
        
       

     

       158
        
       		var modVer string

     

       159
       +
       		var sha string

     

       160
       +
       		var modified bool

     

       161
       +
       

     

       162
        
       		for _, mod := range info.Deps {

     

       163
        
       			if mod.Path == "tangled.sh/tangled.sh/knotserver" {

     

       164
       +
       				modVer = mod.Version

     

       165
        
       				break

     

       166
        
       			}

     

       167
        
       		}

     

       168
        
       

     

       169
       +
       		for _, setting := range info.Settings {

     

       170
       +
       			switch setting.Key {

     

       171
       +
       			case "vcs.revision":

     

       172
       +
       				sha = setting.Value

     

       173
       +
       			case "vcs.modified":

     

       174
       +
       				modified = setting.Value == "true"

     

       175
       +
       			}

     

       176
       +
       		}

     

       177
       +
       

     

       178
        
       		if modVer == "" {

     

       179
       +
       			modVer = "unknown"

     

       180
       +
       		}

     

       181
       +
       

     

       182
       +
       		if sha == "" {

     

       183
       +
       			version = modVer

     

       184
       +
       		} else if modified {

     

       185
       +
       			version = fmt.Sprintf("%s (%s with modifications)", modVer, sha)

     

       186
       +
       		} else {

     

       187
       +
       			version = fmt.Sprintf("%s (%s)", modVer, sha)

     

       188
        
       		}

     

       189
        
       	}

     

       190

+1 -1

patchutil/combinediff.go

···

       119
        
       			// we have f1 and f2, combine them

     

       120
        
       			combined, err := combineFiles(f1, f2)

     

       121
        
       			if err != nil {

     

       122
       -
       				fmt.Println(err)

     

       123
        
       			}

     

       124
        
       

     

       125
        
       			// combined can be nil commit 2 reverted all changes from commit 1

···

       119
        
       			// we have f1 and f2, combine them

     

       120
        
       			combined, err := combineFiles(f1, f2)

     

       121
        
       			if err != nil {

     

       122
       +
       				// fmt.Println(err)

     

       123
        
       			}

     

       124
        
       

     

       125
        
       			// combined can be nil commit 2 reverted all changes from commit 1

+1 -1

appview/pages/templates/errors/knot404.html

···

       17
        
                       The repository you were looking for could not be found. The knot serving the repository may be unavailable.

     

       18
        
                   </p>

     

       19
        
                   <div class="flex flex-col sm:flex-row gap-3 justify-center items-center mt-6">

     

       20
       -
                       <a href="/" class="btn px-4 py-2 rounded flex items-center gap-2 no-underline hover:no-underline">

     

       21
        
                           {{ i "arrow-left" "w-4 h-4" }}

     

       22
        
                           back to timeline

     

       23
        
                       </a>

···

       17
        
                       The repository you were looking for could not be found. The knot serving the repository may be unavailable.

     

       18
        
                   </p>

     

       19
        
                   <div class="flex flex-col sm:flex-row gap-3 justify-center items-center mt-6">

     

       20
       +
                       <a href="/" class="btn flex items-center gap-2 no-underline hover:no-underline">

     

       21
        
                           {{ i "arrow-left" "w-4 h-4" }}

     

       22
        
                           back to timeline

     

       23
        
                       </a>

+109

legal/terms.md

···

       1
       +
       # Terms of Service

     

       2
       +
       

     

       3
       +
       **Last updated:** January 15, 2025

     

       4
       +
       

     

       5
       +
       Welcome to Tangled. These Terms of Service ("Terms") govern your access

     

       6
       +
       to and use of the Tangled platform and services (the "Service")

     

       7
       +
       operated by us ("Tangled," "we," "us," or "our").

     

       8
       +
       

     

       9
       +
       ## 1. Acceptance of Terms

     

       10
       +
       

     

       11
       +
       By accessing or using our Service, you agree to be bound by these Terms.

     

       12
       +
       If you disagree with any part of these terms, then you may not access

     

       13
       +
       the Service.

     

       14
       +
       

     

       15
       +
       ## 2. Account Registration

     

       16
       +
       

     

       17
       +
       To use certain features of the Service, you must register for an

     

       18
       +
       account. You agree to provide accurate, current, and complete

     

       19
       +
       information during the registration process and to update such

     

       20
       +
       information to keep it accurate, current, and complete.

     

       21
       +
       

     

       22
       +
       ## 3. Account Termination

     

       23
       +
       

     

       24
       +
       > **Important Notice**

     

       25
       +
       > 

     

       26
       +
       > **We reserve the right to terminate, suspend, or restrict access to

     

       27
       +
       > your account at any time, for any reason, or for no reason at all, at

     

       28
       +
       > our sole discretion.** This includes, but is not limited to,

     

       29
       +
       > termination for violation of these Terms, inappropriate conduct, spam,

     

       30
       +
       > abuse, or any other behavior we deem harmful to the Service or other

     

       31
       +
       > users.

     

       32
       +
       > 

     

       33
       +
       > Account termination may result in the loss of access to your

     

       34
       +
       > repositories, data, and other content associated with your account. We

     

       35
       +
       > are not obligated to provide advance notice of termination, though we

     

       36
       +
       > may do so in our discretion.

     

       37
       +
       

     

       38
       +
       ## 4. Acceptable Use

     

       39
       +
       

     

       40
       +
       You agree not to use the Service to:

     

       41
       +
       

     

       42
       +
       - Violate any applicable laws or regulations

     

       43
       +
       - Infringe upon the rights of others

     

       44
       +
       - Upload, store, or share content that is illegal, harmful, threatening,

     

       45
       +
         abusive, harassing, defamatory, vulgar, obscene, or otherwise

     

       46
       +
         objectionable

     

       47
       +
       - Engage in spam, phishing, or other deceptive practices

     

       48
       +
       - Attempt to gain unauthorized access to the Service or other users'

     

       49
       +
         accounts

     

       50
       +
       - Interfere with or disrupt the Service or servers connected to the

     

       51
       +
         Service

     

       52
       +
       

     

       53
       +
       ## 5. Content and Intellectual Property

     

       54
       +
       

     

       55
       +
       You retain ownership of the content you upload to the Service. By

     

       56
       +
       uploading content, you grant us a non-exclusive, worldwide, royalty-free

     

       57
       +
       license to use, reproduce, modify, and distribute your content as

     

       58
       +
       necessary to provide the Service.

     

       59
       +
       

     

       60
       +
       ## 6. Privacy

     

       61
       +
       

     

       62
       +
       Your privacy is important to us. Please review our [Privacy

     

       63
       +
       Policy](/privacy), which also governs your use of the Service.

     

       64
       +
       

     

       65
       +
       ## 7. Disclaimers

     

       66
       +
       

     

       67
       +
       The Service is provided on an "AS IS" and "AS AVAILABLE" basis. We make

     

       68
       +
       no warranties, expressed or implied, and hereby disclaim and negate all

     

       69
       +
       other warranties including without limitation, implied warranties or

     

       70
       +
       conditions of merchantability, fitness for a particular purpose, or

     

       71
       +
       non-infringement of intellectual property or other violation of rights.

     

       72
       +
       

     

       73
       +
       ## 8. Limitation of Liability

     

       74
       +
       

     

       75
       +
       In no event shall Tangled, nor its directors, employees, partners,

     

       76
       +
       agents, suppliers, or affiliates, be liable for any indirect,

     

       77
       +
       incidental, special, consequential, or punitive damages, including

     

       78
       +
       without limitation, loss of profits, data, use, goodwill, or other

     

       79
       +
       intangible losses, resulting from your use of the Service.

     

       80
       +
       

     

       81
       +
       ## 9. Indemnification

     

       82
       +
       

     

       83
       +
       You agree to defend, indemnify, and hold harmless Tangled and its

     

       84
       +
       affiliates, officers, directors, employees, and agents from and against

     

       85
       +
       any and all claims, damages, obligations, losses, liabilities, costs,

     

       86
       +
       or debt, and expenses (including attorney's fees).

     

       87
       +
       

     

       88
       +
       ## 10. Governing Law

     

       89
       +
       

     

       90
       +
       These Terms shall be interpreted and governed by the laws of Finland,

     

       91
       +
       without regard to its conflict of law provisions.

     

       92
       +
       

     

       93
       +
       ## 11. Changes to Terms

     

       94
       +
       

     

       95
       +
       We reserve the right to modify or replace these Terms at any time. If a

     

       96
       +
       revision is material, we will try to provide at least 30 days notice

     

       97
       +
       prior to any new terms taking effect.

     

       98
       +
       

     

       99
       +
       ## 12. Contact Information

     

       100
       +
       

     

       101
       +
       If you have any questions about these Terms of Service, please contact

     

       102
       +
       us through our platform or via email.

     

       103
       +
       

     

       104
       +
       ---

     

       105
       +
       

     

       106
       +
       These terms are effective as of the last updated date shown above and

     

       107
       +
       will remain in effect except with respect to any changes in their

     

       108
       +
       provisions in the future, which will be in effect immediately after

     

       109
       +
       being posted on this page.

+2 -2

appview/pages/templates/user/settings/profile.html

···

       4
        
         <div class="p-6">

     

       5
        
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
        
         </div>

     

       7
       -
         <div class="bg-white dark:bg-gray-800">

     

       8
       -
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6 p-6">

     

       9
        
             <div class="col-span-1">

     

       10
        
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
        
             </div>

···

       4
        
         <div class="p-6">

     

       5
        
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
        
         </div>

     

       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
        
             <div class="col-span-1">

     

       10
        
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
        
             </div>

+53

api/tangled/knotlistKeys.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.knot.listKeys

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	KnotListKeysNSID = "sh.tangled.knot.listKeys"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // KnotListKeys_Output is the output of a sh.tangled.knot.listKeys call.

     

       18
       +
       type KnotListKeys_Output struct {

     

       19
       +
       	// cursor: Pagination cursor for next page

     

       20
       +
       	Cursor *string                   `json:"cursor,omitempty" cborgen:"cursor,omitempty"`

     

       21
       +
       	Keys   []*KnotListKeys_PublicKey `json:"keys" cborgen:"keys"`

     

       22
       +
       }

     

       23
       +
       

     

       24
       +
       // KnotListKeys_PublicKey is a "publicKey" in the sh.tangled.knot.listKeys schema.

     

       25
       +
       type KnotListKeys_PublicKey struct {

     

       26
       +
       	// createdAt: Key upload timestamp

     

       27
       +
       	CreatedAt string `json:"createdAt" cborgen:"createdAt"`

     

       28
       +
       	// did: DID associated with the public key

     

       29
       +
       	Did string `json:"did" cborgen:"did"`

     

       30
       +
       	// key: Public key contents

     

       31
       +
       	Key string `json:"key" cborgen:"key"`

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       // KnotListKeys calls the XRPC method "sh.tangled.knot.listKeys".

     

       35
       +
       //

     

       36
       +
       // cursor: Pagination cursor

     

       37
       +
       // limit: Maximum number of keys to return

     

       38
       +
       func KnotListKeys(ctx context.Context, c util.LexClient, cursor string, limit int64) (*KnotListKeys_Output, error) {

     

       39
       +
       	var out KnotListKeys_Output

     

       40
       +
       

     

       41
       +
       	params := map[string]interface{}{}

     

       42
       +
       	if cursor != "" {

     

       43
       +
       		params["cursor"] = cursor

     

       44
       +
       	}

     

       45
       +
       	if limit != 0 {

     

       46
       +
       		params["limit"] = limit

     

       47
       +
       	}

     

       48
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.listKeys", params, nil, &out); err != nil {

     

       49
       +
       		return nil, err

     

       50
       +
       	}

     

       51
       +
       

     

       52
       +
       	return &out, nil

     

       53
       +
       }

+41

api/tangled/repoarchive.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.archive

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoArchiveNSID = "sh.tangled.repo.archive"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoArchive calls the XRPC method "sh.tangled.repo.archive".

     

       19
       +
       //

     

       20
       +
       // format: Archive format

     

       21
       +
       // prefix: Prefix for files in the archive

     

       22
       +
       // ref: Git reference (branch, tag, or commit SHA)

     

       23
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       24
       +
       func RepoArchive(ctx context.Context, c util.LexClient, format string, prefix string, ref string, repo string) ([]byte, error) {

     

       25
       +
       	buf := new(bytes.Buffer)

     

       26
       +
       

     

       27
       +
       	params := map[string]interface{}{}

     

       28
       +
       	if format != "" {

     

       29
       +
       		params["format"] = format

     

       30
       +
       	}

     

       31
       +
       	if prefix != "" {

     

       32
       +
       		params["prefix"] = prefix

     

       33
       +
       	}

     

       34
       +
       	params["ref"] = ref

     

       35
       +
       	params["repo"] = repo

     

       36
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.archive", params, nil, buf); err != nil {

     

       37
       +
       		return nil, err

     

       38
       +
       	}

     

       39
       +
       

     

       40
       +
       	return buf.Bytes(), nil

     

       41
       +
       }

+80

api/tangled/repoblob.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.blob

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoBlobNSID = "sh.tangled.repo.blob"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoBlob_LastCommit is a "lastCommit" in the sh.tangled.repo.blob schema.

     

       18
       +
       type RepoBlob_LastCommit struct {

     

       19
       +
       	Author *RepoBlob_Signature `json:"author,omitempty" cborgen:"author,omitempty"`

     

       20
       +
       	// hash: Commit hash

     

       21
       +
       	Hash string `json:"hash" cborgen:"hash"`

     

       22
       +
       	// message: Commit message

     

       23
       +
       	Message string `json:"message" cborgen:"message"`

     

       24
       +
       	// shortHash: Short commit hash

     

       25
       +
       	ShortHash *string `json:"shortHash,omitempty" cborgen:"shortHash,omitempty"`

     

       26
       +
       	// when: Commit timestamp

     

       27
       +
       	When string `json:"when" cborgen:"when"`

     

       28
       +
       }

     

       29
       +
       

     

       30
       +
       // RepoBlob_Output is the output of a sh.tangled.repo.blob call.

     

       31
       +
       type RepoBlob_Output struct {

     

       32
       +
       	// content: File content (base64 encoded for binary files)

     

       33
       +
       	Content string `json:"content" cborgen:"content"`

     

       34
       +
       	// encoding: Content encoding

     

       35
       +
       	Encoding *string `json:"encoding,omitempty" cborgen:"encoding,omitempty"`

     

       36
       +
       	// isBinary: Whether the file is binary

     

       37
       +
       	IsBinary   *bool                `json:"isBinary,omitempty" cborgen:"isBinary,omitempty"`

     

       38
       +
       	LastCommit *RepoBlob_LastCommit `json:"lastCommit,omitempty" cborgen:"lastCommit,omitempty"`

     

       39
       +
       	// mimeType: MIME type of the file

     

       40
       +
       	MimeType *string `json:"mimeType,omitempty" cborgen:"mimeType,omitempty"`

     

       41
       +
       	// path: The file path

     

       42
       +
       	Path string `json:"path" cborgen:"path"`

     

       43
       +
       	// ref: The git reference used

     

       44
       +
       	Ref string `json:"ref" cborgen:"ref"`

     

       45
       +
       	// size: File size in bytes

     

       46
       +
       	Size *int64 `json:"size,omitempty" cborgen:"size,omitempty"`

     

       47
       +
       }

     

       48
       +
       

     

       49
       +
       // RepoBlob_Signature is a "signature" in the sh.tangled.repo.blob schema.

     

       50
       +
       type RepoBlob_Signature struct {

     

       51
       +
       	// email: Author email

     

       52
       +
       	Email string `json:"email" cborgen:"email"`

     

       53
       +
       	// name: Author name

     

       54
       +
       	Name string `json:"name" cborgen:"name"`

     

       55
       +
       	// when: Author timestamp

     

       56
       +
       	When string `json:"when" cborgen:"when"`

     

       57
       +
       }

     

       58
       +
       

     

       59
       +
       // RepoBlob calls the XRPC method "sh.tangled.repo.blob".

     

       60
       +
       //

     

       61
       +
       // path: Path to the file within the repository

     

       62
       +
       // raw: Return raw file content instead of JSON response

     

       63
       +
       // ref: Git reference (branch, tag, or commit SHA)

     

       64
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       65
       +
       func RepoBlob(ctx context.Context, c util.LexClient, path string, raw bool, ref string, repo string) (*RepoBlob_Output, error) {

     

       66
       +
       	var out RepoBlob_Output

     

       67
       +
       

     

       68
       +
       	params := map[string]interface{}{}

     

       69
       +
       	params["path"] = path

     

       70
       +
       	if raw {

     

       71
       +
       		params["raw"] = raw

     

       72
       +
       	}

     

       73
       +
       	params["ref"] = ref

     

       74
       +
       	params["repo"] = repo

     

       75
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.blob", params, nil, &out); err != nil {

     

       76
       +
       		return nil, err

     

       77
       +
       	}

     

       78
       +
       

     

       79
       +
       	return &out, nil

     

       80
       +
       }

+59

api/tangled/repobranch.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.branch

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoBranchNSID = "sh.tangled.repo.branch"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoBranch_Output is the output of a sh.tangled.repo.branch call.

     

       18
       +
       type RepoBranch_Output struct {

     

       19
       +
       	Author *RepoBranch_Signature `json:"author,omitempty" cborgen:"author,omitempty"`

     

       20
       +
       	// hash: Latest commit hash on this branch

     

       21
       +
       	Hash string `json:"hash" cborgen:"hash"`

     

       22
       +
       	// isDefault: Whether this is the default branch

     

       23
       +
       	IsDefault *bool `json:"isDefault,omitempty" cborgen:"isDefault,omitempty"`

     

       24
       +
       	// message: Latest commit message

     

       25
       +
       	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`

     

       26
       +
       	// name: Branch name

     

       27
       +
       	Name string `json:"name" cborgen:"name"`

     

       28
       +
       	// shortHash: Short commit hash

     

       29
       +
       	ShortHash *string `json:"shortHash,omitempty" cborgen:"shortHash,omitempty"`

     

       30
       +
       	// when: Timestamp of latest commit

     

       31
       +
       	When string `json:"when" cborgen:"when"`

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       // RepoBranch_Signature is a "signature" in the sh.tangled.repo.branch schema.

     

       35
       +
       type RepoBranch_Signature struct {

     

       36
       +
       	// email: Author email

     

       37
       +
       	Email string `json:"email" cborgen:"email"`

     

       38
       +
       	// name: Author name

     

       39
       +
       	Name string `json:"name" cborgen:"name"`

     

       40
       +
       	// when: Author timestamp

     

       41
       +
       	When string `json:"when" cborgen:"when"`

     

       42
       +
       }

     

       43
       +
       

     

       44
       +
       // RepoBranch calls the XRPC method "sh.tangled.repo.branch".

     

       45
       +
       //

     

       46
       +
       // name: Branch name to get information for

     

       47
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       48
       +
       func RepoBranch(ctx context.Context, c util.LexClient, name string, repo string) (*RepoBranch_Output, error) {

     

       49
       +
       	var out RepoBranch_Output

     

       50
       +
       

     

       51
       +
       	params := map[string]interface{}{}

     

       52
       +
       	params["name"] = name

     

       53
       +
       	params["repo"] = repo

     

       54
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.branch", params, nil, &out); err != nil {

     

       55
       +
       		return nil, err

     

       56
       +
       	}

     

       57
       +
       

     

       58
       +
       	return &out, nil

     

       59
       +
       }

+39

api/tangled/repobranches.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.branches

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoBranchesNSID = "sh.tangled.repo.branches"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoBranches calls the XRPC method "sh.tangled.repo.branches".

     

       19
       +
       //

     

       20
       +
       // cursor: Pagination cursor

     

       21
       +
       // limit: Maximum number of branches to return

     

       22
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       23
       +
       func RepoBranches(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {

     

       24
       +
       	buf := new(bytes.Buffer)

     

       25
       +
       

     

       26
       +
       	params := map[string]interface{}{}

     

       27
       +
       	if cursor != "" {

     

       28
       +
       		params["cursor"] = cursor

     

       29
       +
       	}

     

       30
       +
       	if limit != 0 {

     

       31
       +
       		params["limit"] = limit

     

       32
       +
       	}

     

       33
       +
       	params["repo"] = repo

     

       34
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.branches", params, nil, buf); err != nil {

     

       35
       +
       		return nil, err

     

       36
       +
       	}

     

       37
       +
       

     

       38
       +
       	return buf.Bytes(), nil

     

       39
       +
       }

+35

api/tangled/repocompare.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.compare

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoCompareNSID = "sh.tangled.repo.compare"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoCompare calls the XRPC method "sh.tangled.repo.compare".

     

       19
       +
       //

     

       20
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       21
       +
       // rev1: First revision (commit, branch, or tag)

     

       22
       +
       // rev2: Second revision (commit, branch, or tag)

     

       23
       +
       func RepoCompare(ctx context.Context, c util.LexClient, repo string, rev1 string, rev2 string) ([]byte, error) {

     

       24
       +
       	buf := new(bytes.Buffer)

     

       25
       +
       

     

       26
       +
       	params := map[string]interface{}{}

     

       27
       +
       	params["repo"] = repo

     

       28
       +
       	params["rev1"] = rev1

     

       29
       +
       	params["rev2"] = rev2

     

       30
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.compare", params, nil, buf); err != nil {

     

       31
       +
       		return nil, err

     

       32
       +
       	}

     

       33
       +
       

     

       34
       +
       	return buf.Bytes(), nil

     

       35
       +
       }

+33

api/tangled/repodiff.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.diff

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoDiffNSID = "sh.tangled.repo.diff"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoDiff calls the XRPC method "sh.tangled.repo.diff".

     

       19
       +
       //

     

       20
       +
       // ref: Git reference (branch, tag, or commit SHA)

     

       21
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       22
       +
       func RepoDiff(ctx context.Context, c util.LexClient, ref string, repo string) ([]byte, error) {

     

       23
       +
       	buf := new(bytes.Buffer)

     

       24
       +
       

     

       25
       +
       	params := map[string]interface{}{}

     

       26
       +
       	params["ref"] = ref

     

       27
       +
       	params["repo"] = repo

     

       28
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.diff", params, nil, buf); err != nil {

     

       29
       +
       		return nil, err

     

       30
       +
       	}

     

       31
       +
       

     

       32
       +
       	return buf.Bytes(), nil

     

       33
       +
       }

+55

api/tangled/repogetDefaultBranch.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.getDefaultBranch

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoGetDefaultBranchNSID = "sh.tangled.repo.getDefaultBranch"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoGetDefaultBranch_Output is the output of a sh.tangled.repo.getDefaultBranch call.

     

       18
       +
       type RepoGetDefaultBranch_Output struct {

     

       19
       +
       	Author *RepoGetDefaultBranch_Signature `json:"author,omitempty" cborgen:"author,omitempty"`

     

       20
       +
       	// hash: Latest commit hash on default branch

     

       21
       +
       	Hash string `json:"hash" cborgen:"hash"`

     

       22
       +
       	// message: Latest commit message

     

       23
       +
       	Message *string `json:"message,omitempty" cborgen:"message,omitempty"`

     

       24
       +
       	// name: Default branch name

     

       25
       +
       	Name string `json:"name" cborgen:"name"`

     

       26
       +
       	// shortHash: Short commit hash

     

       27
       +
       	ShortHash *string `json:"shortHash,omitempty" cborgen:"shortHash,omitempty"`

     

       28
       +
       	// when: Timestamp of latest commit

     

       29
       +
       	When string `json:"when" cborgen:"when"`

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       // RepoGetDefaultBranch_Signature is a "signature" in the sh.tangled.repo.getDefaultBranch schema.

     

       33
       +
       type RepoGetDefaultBranch_Signature struct {

     

       34
       +
       	// email: Author email

     

       35
       +
       	Email string `json:"email" cborgen:"email"`

     

       36
       +
       	// name: Author name

     

       37
       +
       	Name string `json:"name" cborgen:"name"`

     

       38
       +
       	// when: Author timestamp

     

       39
       +
       	When string `json:"when" cborgen:"when"`

     

       40
       +
       }

     

       41
       +
       

     

       42
       +
       // RepoGetDefaultBranch calls the XRPC method "sh.tangled.repo.getDefaultBranch".

     

       43
       +
       //

     

       44
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       45
       +
       func RepoGetDefaultBranch(ctx context.Context, c util.LexClient, repo string) (*RepoGetDefaultBranch_Output, error) {

     

       46
       +
       	var out RepoGetDefaultBranch_Output

     

       47
       +
       

     

       48
       +
       	params := map[string]interface{}{}

     

       49
       +
       	params["repo"] = repo

     

       50
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.getDefaultBranch", params, nil, &out); err != nil {

     

       51
       +
       		return nil, err

     

       52
       +
       	}

     

       53
       +
       

     

       54
       +
       	return &out, nil

     

       55
       +
       }

+61

api/tangled/repolanguages.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.languages

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	RepoLanguagesNSID = "sh.tangled.repo.languages"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // RepoLanguages_Language is a "language" in the sh.tangled.repo.languages schema.

     

       18
       +
       type RepoLanguages_Language struct {

     

       19
       +
       	// color: Hex color code for this language

     

       20
       +
       	Color *string `json:"color,omitempty" cborgen:"color,omitempty"`

     

       21
       +
       	// extensions: File extensions associated with this language

     

       22
       +
       	Extensions []string `json:"extensions,omitempty" cborgen:"extensions,omitempty"`

     

       23
       +
       	// fileCount: Number of files in this language

     

       24
       +
       	FileCount *int64 `json:"fileCount,omitempty" cborgen:"fileCount,omitempty"`

     

       25
       +
       	// name: Programming language name

     

       26
       +
       	Name string `json:"name" cborgen:"name"`

     

       27
       +
       	// percentage: Percentage of total codebase (0-100)

     

       28
       +
       	Percentage int64 `json:"percentage" cborgen:"percentage"`

     

       29
       +
       	// size: Total size of files in this language (bytes)

     

       30
       +
       	Size int64 `json:"size" cborgen:"size"`

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       // RepoLanguages_Output is the output of a sh.tangled.repo.languages call.

     

       34
       +
       type RepoLanguages_Output struct {

     

       35
       +
       	Languages []*RepoLanguages_Language `json:"languages" cborgen:"languages"`

     

       36
       +
       	// ref: The git reference used

     

       37
       +
       	Ref string `json:"ref" cborgen:"ref"`

     

       38
       +
       	// totalFiles: Total number of files analyzed

     

       39
       +
       	TotalFiles *int64 `json:"totalFiles,omitempty" cborgen:"totalFiles,omitempty"`

     

       40
       +
       	// totalSize: Total size of all analyzed files in bytes

     

       41
       +
       	TotalSize *int64 `json:"totalSize,omitempty" cborgen:"totalSize,omitempty"`

     

       42
       +
       }

     

       43
       +
       

     

       44
       +
       // RepoLanguages calls the XRPC method "sh.tangled.repo.languages".

     

       45
       +
       //

     

       46
       +
       // ref: Git reference (branch, tag, or commit SHA)

     

       47
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       48
       +
       func RepoLanguages(ctx context.Context, c util.LexClient, ref string, repo string) (*RepoLanguages_Output, error) {

     

       49
       +
       	var out RepoLanguages_Output

     

       50
       +
       

     

       51
       +
       	params := map[string]interface{}{}

     

       52
       +
       	if ref != "" {

     

       53
       +
       		params["ref"] = ref

     

       54
       +
       	}

     

       55
       +
       	params["repo"] = repo

     

       56
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.languages", params, nil, &out); err != nil {

     

       57
       +
       		return nil, err

     

       58
       +
       	}

     

       59
       +
       

     

       60
       +
       	return &out, nil

     

       61
       +
       }

+45

api/tangled/repolog.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.log

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoLogNSID = "sh.tangled.repo.log"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoLog calls the XRPC method "sh.tangled.repo.log".

     

       19
       +
       //

     

       20
       +
       // cursor: Pagination cursor (commit SHA)

     

       21
       +
       // limit: Maximum number of commits to return

     

       22
       +
       // path: Path to filter commits by

     

       23
       +
       // ref: Git reference (branch, tag, or commit SHA)

     

       24
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       25
       +
       func RepoLog(ctx context.Context, c util.LexClient, cursor string, limit int64, path string, ref string, repo string) ([]byte, error) {

     

       26
       +
       	buf := new(bytes.Buffer)

     

       27
       +
       

     

       28
       +
       	params := map[string]interface{}{}

     

       29
       +
       	if cursor != "" {

     

       30
       +
       		params["cursor"] = cursor

     

       31
       +
       	}

     

       32
       +
       	if limit != 0 {

     

       33
       +
       		params["limit"] = limit

     

       34
       +
       	}

     

       35
       +
       	if path != "" {

     

       36
       +
       		params["path"] = path

     

       37
       +
       	}

     

       38
       +
       	params["ref"] = ref

     

       39
       +
       	params["repo"] = repo

     

       40
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.log", params, nil, buf); err != nil {

     

       41
       +
       		return nil, err

     

       42
       +
       	}

     

       43
       +
       

     

       44
       +
       	return buf.Bytes(), nil

     

       45
       +
       }

+39

api/tangled/repotags.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.repo.tags

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"bytes"

     

       9
       +
       	"context"

     

       10
       +
       

     

       11
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       const (

     

       15
       +
       	RepoTagsNSID = "sh.tangled.repo.tags"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       // RepoTags calls the XRPC method "sh.tangled.repo.tags".

     

       19
       +
       //

     

       20
       +
       // cursor: Pagination cursor

     

       21
       +
       // limit: Maximum number of tags to return

     

       22
       +
       // repo: Repository identifier in format 'did:plc:.../repoName'

     

       23
       +
       func RepoTags(ctx context.Context, c util.LexClient, cursor string, limit int64, repo string) ([]byte, error) {

     

       24
       +
       	buf := new(bytes.Buffer)

     

       25
       +
       

     

       26
       +
       	params := map[string]interface{}{}

     

       27
       +
       	if cursor != "" {

     

       28
       +
       		params["cursor"] = cursor

     

       29
       +
       	}

     

       30
       +
       	if limit != 0 {

     

       31
       +
       		params["limit"] = limit

     

       32
       +
       	}

     

       33
       +
       	params["repo"] = repo

     

       34
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.repo.tags", params, nil, buf); err != nil {

     

       35
       +
       		return nil, err

     

       36
       +
       	}

     

       37
       +
       

     

       38
       +
       	return buf.Bytes(), nil

     

       39
       +
       }

+73

lexicons/knot/listKeys.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.knot.listKeys",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "description": "List all public keys stored in the knot server",

     

       8
       +
             "parameters": {

     

       9
       +
               "type": "params",

     

       10
       +
               "properties": {

     

       11
       +
                 "limit": {

     

       12
       +
                   "type": "integer",

     

       13
       +
                   "description": "Maximum number of keys to return",

     

       14
       +
                   "minimum": 1,

     

       15
       +
                   "maximum": 1000,

     

       16
       +
                   "default": 100

     

       17
       +
                 },

     

       18
       +
                 "cursor": {

     

       19
       +
                   "type": "string",

     

       20
       +
                   "description": "Pagination cursor"

     

       21
       +
                 }

     

       22
       +
               }

     

       23
       +
             },

     

       24
       +
             "output": {

     

       25
       +
               "encoding": "application/json",

     

       26
       +
               "schema": {

     

       27
       +
                 "type": "object",

     

       28
       +
                 "required": ["keys"],

     

       29
       +
                 "properties": {

     

       30
       +
                   "keys": {

     

       31
       +
                     "type": "array",

     

       32
       +
                     "items": {

     

       33
       +
                       "type": "ref",

     

       34
       +
                       "ref": "#publicKey"

     

       35
       +
                     }

     

       36
       +
                   },

     

       37
       +
                   "cursor": {

     

       38
       +
                     "type": "string",

     

       39
       +
                     "description": "Pagination cursor for next page"

     

       40
       +
                   }

     

       41
       +
                 }

     

       42
       +
               }

     

       43
       +
             },

     

       44
       +
             "errors": [

     

       45
       +
               {

     

       46
       +
                 "name": "InternalServerError",

     

       47
       +
                 "description": "Failed to retrieve public keys"

     

       48
       +
               }

     

       49
       +
             ]

     

       50
       +
           },

     

       51
       +
           "publicKey": {

     

       52
       +
             "type": "object",

     

       53
       +
             "required": ["did", "key", "createdAt"],

     

       54
       +
             "properties": {

     

       55
       +
               "did": {

     

       56
       +
                 "type": "string",

     

       57
       +
                 "format": "did",

     

       58
       +
                 "description": "DID associated with the public key"

     

       59
       +
               },

     

       60
       +
               "key": {

     

       61
       +
                 "type": "string",

     

       62
       +
                 "maxLength": 4096,

     

       63
       +
                 "description": "Public key contents"

     

       64
       +
               },

     

       65
       +
               "createdAt": {

     

       66
       +
                 "type": "string",

     

       67
       +
                 "format": "datetime",

     

       68
       +
                 "description": "Key upload timestamp"

     

       69
       +
               }

     

       70
       +
             }

     

       71
       +
           }

     

       72
       +
         }

     

       73
       +
       }

+55

lexicons/repo/archive.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.archive",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "ref"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "ref": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Git reference (branch, tag, or commit SHA)"

     

       18
       +
                 },

     

       19
       +
                 "format": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "description": "Archive format",

     

       22
       +
                   "enum": ["tar", "zip", "tar.gz", "tar.bz2", "tar.xz"],

     

       23
       +
                   "default": "tar.gz"

     

       24
       +
                 },

     

       25
       +
                 "prefix": {

     

       26
       +
                   "type": "string",

     

       27
       +
                   "description": "Prefix for files in the archive"

     

       28
       +
                 }

     

       29
       +
               }

     

       30
       +
             },

     

       31
       +
             "output": {

     

       32
       +
               "encoding": "*/*",

     

       33
       +
               "description": "Binary archive data"

     

       34
       +
             },

     

       35
       +
             "errors": [

     

       36
       +
               {

     

       37
       +
                 "name": "RepoNotFound",

     

       38
       +
                 "description": "Repository not found or access denied"

     

       39
       +
               },

     

       40
       +
               {

     

       41
       +
                 "name": "RefNotFound",

     

       42
       +
                 "description": "Git reference not found"

     

       43
       +
               },

     

       44
       +
               {

     

       45
       +
                 "name": "InvalidRequest",

     

       46
       +
                 "description": "Invalid request parameters"

     

       47
       +
               },

     

       48
       +
               {

     

       49
       +
                 "name": "ArchiveError",

     

       50
       +
                 "description": "Failed to create archive"

     

       51
       +
               }

     

       52
       +
             ]

     

       53
       +
           }

     

       54
       +
         }

     

       55
       +
       }

+138

lexicons/repo/blob.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.blob",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "ref", "path"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "ref": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Git reference (branch, tag, or commit SHA)"

     

       18
       +
                 },

     

       19
       +
                 "path": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "description": "Path to the file within the repository"

     

       22
       +
                 },

     

       23
       +
                 "raw": {

     

       24
       +
                   "type": "boolean",

     

       25
       +
                   "description": "Return raw file content instead of JSON response",

     

       26
       +
                   "default": false

     

       27
       +
                 }

     

       28
       +
               }

     

       29
       +
             },

     

       30
       +
             "output": {

     

       31
       +
               "encoding": "application/json",

     

       32
       +
               "schema": {

     

       33
       +
                 "type": "object",

     

       34
       +
                 "required": ["ref", "path", "content"],

     

       35
       +
                 "properties": {

     

       36
       +
                   "ref": {

     

       37
       +
                     "type": "string",

     

       38
       +
                     "description": "The git reference used"

     

       39
       +
                   },

     

       40
       +
                   "path": {

     

       41
       +
                     "type": "string",

     

       42
       +
                     "description": "The file path"

     

       43
       +
                   },

     

       44
       +
                   "content": {

     

       45
       +
                     "type": "string",

     

       46
       +
                     "description": "File content (base64 encoded for binary files)"

     

       47
       +
                   },

     

       48
       +
                   "encoding": {

     

       49
       +
                     "type": "string",

     

       50
       +
                     "description": "Content encoding",

     

       51
       +
                     "enum": ["utf-8", "base64"]

     

       52
       +
                   },

     

       53
       +
                   "size": {

     

       54
       +
                     "type": "integer",

     

       55
       +
                     "description": "File size in bytes"

     

       56
       +
                   },

     

       57
       +
                   "isBinary": {

     

       58
       +
                     "type": "boolean",

     

       59
       +
                     "description": "Whether the file is binary"

     

       60
       +
                   },

     

       61
       +
                   "mimeType": {

     

       62
       +
                     "type": "string",

     

       63
       +
                     "description": "MIME type of the file"

     

       64
       +
                   },

     

       65
       +
                   "lastCommit": {

     

       66
       +
                     "type": "ref",

     

       67
       +
                     "ref": "#lastCommit"

     

       68
       +
                   }

     

       69
       +
                 }

     

       70
       +
               }

     

       71
       +
             },

     

       72
       +
             "errors": [

     

       73
       +
               {

     

       74
       +
                 "name": "RepoNotFound",

     

       75
       +
                 "description": "Repository not found or access denied"

     

       76
       +
               },

     

       77
       +
               {

     

       78
       +
                 "name": "RefNotFound",

     

       79
       +
                 "description": "Git reference not found"

     

       80
       +
               },

     

       81
       +
               {

     

       82
       +
                 "name": "FileNotFound",

     

       83
       +
                 "description": "File not found at the specified path"

     

       84
       +
               },

     

       85
       +
               {

     

       86
       +
                 "name": "InvalidRequest",

     

       87
       +
                 "description": "Invalid request parameters"

     

       88
       +
               }

     

       89
       +
             ]

     

       90
       +
           },

     

       91
       +
           "lastCommit": {

     

       92
       +
             "type": "object",

     

       93
       +
             "required": ["hash", "message", "when"],

     

       94
       +
             "properties": {

     

       95
       +
               "hash": {

     

       96
       +
                 "type": "string",

     

       97
       +
                 "description": "Commit hash"

     

       98
       +
               },

     

       99
       +
               "shortHash": {

     

       100
       +
                 "type": "string",

     

       101
       +
                 "description": "Short commit hash"

     

       102
       +
               },

     

       103
       +
               "message": {

     

       104
       +
                 "type": "string",

     

       105
       +
                 "description": "Commit message"

     

       106
       +
               },

     

       107
       +
               "author": {

     

       108
       +
                 "type": "ref",

     

       109
       +
                 "ref": "#signature"

     

       110
       +
               },

     

       111
       +
               "when": {

     

       112
       +
                 "type": "string",

     

       113
       +
                 "format": "datetime",

     

       114
       +
                 "description": "Commit timestamp"

     

       115
       +
               }

     

       116
       +
             }

     

       117
       +
           },

     

       118
       +
           "signature": {

     

       119
       +
             "type": "object",

     

       120
       +
             "required": ["name", "email", "when"],

     

       121
       +
             "properties": {

     

       122
       +
               "name": {

     

       123
       +
                 "type": "string",

     

       124
       +
                 "description": "Author name"

     

       125
       +
               },

     

       126
       +
               "email": {

     

       127
       +
                 "type": "string",

     

       128
       +
                 "description": "Author email"

     

       129
       +
               },

     

       130
       +
               "when": {

     

       131
       +
                 "type": "string",

     

       132
       +
                 "format": "datetime",

     

       133
       +
                 "description": "Author timestamp"

     

       134
       +
               }

     

       135
       +
             }

     

       136
       +
           }

     

       137
       +
         }

     

       138
       +
       }

+94

lexicons/repo/branch.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.branch",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "name"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "name": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Branch name to get information for"

     

       18
       +
                 }

     

       19
       +
               }

     

       20
       +
             },

     

       21
       +
             "output": {

     

       22
       +
               "encoding": "application/json",

     

       23
       +
               "schema": {

     

       24
       +
                 "type": "object",

     

       25
       +
                 "required": ["name", "hash", "when"],

     

       26
       +
                 "properties": {

     

       27
       +
                   "name": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Branch name"

     

       30
       +
                   },

     

       31
       +
                   "hash": {

     

       32
       +
                     "type": "string",

     

       33
       +
                     "description": "Latest commit hash on this branch"

     

       34
       +
                   },

     

       35
       +
                   "shortHash": {

     

       36
       +
                     "type": "string",

     

       37
       +
                     "description": "Short commit hash"

     

       38
       +
                   },

     

       39
       +
                   "when": {

     

       40
       +
                     "type": "string",

     

       41
       +
                     "format": "datetime",

     

       42
       +
                     "description": "Timestamp of latest commit"

     

       43
       +
                   },

     

       44
       +
                   "message": {

     

       45
       +
                     "type": "string",

     

       46
       +
                     "description": "Latest commit message"

     

       47
       +
                   },

     

       48
       +
                   "author": {

     

       49
       +
                     "type": "ref",

     

       50
       +
                     "ref": "#signature"

     

       51
       +
                   },

     

       52
       +
                   "isDefault": {

     

       53
       +
                     "type": "boolean",

     

       54
       +
                     "description": "Whether this is the default branch"

     

       55
       +
                   }

     

       56
       +
                 }

     

       57
       +
               }

     

       58
       +
             },

     

       59
       +
             "errors": [

     

       60
       +
               {

     

       61
       +
                 "name": "RepoNotFound",

     

       62
       +
                 "description": "Repository not found or access denied"

     

       63
       +
               },

     

       64
       +
               {

     

       65
       +
                 "name": "BranchNotFound",

     

       66
       +
                 "description": "Branch not found"

     

       67
       +
               },

     

       68
       +
               {

     

       69
       +
                 "name": "InvalidRequest",

     

       70
       +
                 "description": "Invalid request parameters"

     

       71
       +
               }

     

       72
       +
             ]

     

       73
       +
           },

     

       74
       +
           "signature": {

     

       75
       +
             "type": "object",

     

       76
       +
             "required": ["name", "email", "when"],

     

       77
       +
             "properties": {

     

       78
       +
               "name": {

     

       79
       +
                 "type": "string",

     

       80
       +
                 "description": "Author name"

     

       81
       +
               },

     

       82
       +
               "email": {

     

       83
       +
                 "type": "string",

     

       84
       +
                 "description": "Author email"

     

       85
       +
               },

     

       86
       +
               "when": {

     

       87
       +
                 "type": "string",

     

       88
       +
                 "format": "datetime",

     

       89
       +
                 "description": "Author timestamp"

     

       90
       +
               }

     

       91
       +
             }

     

       92
       +
           }

     

       93
       +
         }

     

       94
       +
       }

+43

lexicons/repo/branches.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.branches",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "limit": {

     

       16
       +
                   "type": "integer",

     

       17
       +
                   "description": "Maximum number of branches to return",

     

       18
       +
                   "minimum": 1,

     

       19
       +
                   "maximum": 100,

     

       20
       +
                   "default": 50

     

       21
       +
                 },

     

       22
       +
                 "cursor": {

     

       23
       +
                   "type": "string",

     

       24
       +
                   "description": "Pagination cursor"

     

       25
       +
                 }

     

       26
       +
               }

     

       27
       +
             },

     

       28
       +
             "output": {

     

       29
       +
               "encoding": "*/*"

     

       30
       +
             },

     

       31
       +
             "errors": [

     

       32
       +
               {

     

       33
       +
                 "name": "RepoNotFound",

     

       34
       +
                 "description": "Repository not found or access denied"

     

       35
       +
               },

     

       36
       +
               {

     

       37
       +
                 "name": "InvalidRequest",

     

       38
       +
                 "description": "Invalid request parameters"

     

       39
       +
               }

     

       40
       +
             ]

     

       41
       +
           }

     

       42
       +
         }

     

       43
       +
       }

+49

lexicons/repo/compare.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.compare",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "rev1", "rev2"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "rev1": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "First revision (commit, branch, or tag)"

     

       18
       +
                 },

     

       19
       +
                 "rev2": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "description": "Second revision (commit, branch, or tag)"

     

       22
       +
                 }

     

       23
       +
               }

     

       24
       +
             },

     

       25
       +
             "output": {

     

       26
       +
               "encoding": "*/*",

     

       27
       +
               "description": "Compare output in application/json"

     

       28
       +
             },

     

       29
       +
             "errors": [

     

       30
       +
               {

     

       31
       +
                 "name": "RepoNotFound",

     

       32
       +
                 "description": "Repository not found or access denied"

     

       33
       +
               },

     

       34
       +
               {

     

       35
       +
                 "name": "RevisionNotFound",

     

       36
       +
                 "description": "One or both revisions not found"

     

       37
       +
               },

     

       38
       +
               {

     

       39
       +
                 "name": "InvalidRequest",

     

       40
       +
                 "description": "Invalid request parameters"

     

       41
       +
               },

     

       42
       +
               {

     

       43
       +
                 "name": "CompareError",

     

       44
       +
                 "description": "Failed to compare revisions"

     

       45
       +
               }

     

       46
       +
             ]

     

       47
       +
           }

     

       48
       +
         }

     

       49
       +
       }

+40

lexicons/repo/diff.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.diff",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "ref"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "ref": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Git reference (branch, tag, or commit SHA)"

     

       18
       +
                 }

     

       19
       +
               }

     

       20
       +
             },

     

       21
       +
             "output": {

     

       22
       +
               "encoding": "*/*"

     

       23
       +
             },

     

       24
       +
             "errors": [

     

       25
       +
               {

     

       26
       +
                 "name": "RepoNotFound",

     

       27
       +
                 "description": "Repository not found or access denied"

     

       28
       +
               },

     

       29
       +
               {

     

       30
       +
                 "name": "RefNotFound",

     

       31
       +
                 "description": "Git reference not found"

     

       32
       +
               },

     

       33
       +
               {

     

       34
       +
                 "name": "InvalidRequest",

     

       35
       +
                 "description": "Invalid request parameters"

     

       36
       +
               }

     

       37
       +
             ]

     

       38
       +
           }

     

       39
       +
         }

     

       40
       +
       }

+82

lexicons/repo/getDefaultBranch.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.getDefaultBranch",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 }

     

       15
       +
               }

     

       16
       +
             },

     

       17
       +
             "output": {

     

       18
       +
               "encoding": "application/json",

     

       19
       +
               "schema": {

     

       20
       +
                 "type": "object",

     

       21
       +
                 "required": ["name", "hash", "when"],

     

       22
       +
                 "properties": {

     

       23
       +
                   "name": {

     

       24
       +
                     "type": "string",

     

       25
       +
                     "description": "Default branch name"

     

       26
       +
                   },

     

       27
       +
                   "hash": {

     

       28
       +
                     "type": "string",

     

       29
       +
                     "description": "Latest commit hash on default branch"

     

       30
       +
                   },

     

       31
       +
                   "shortHash": {

     

       32
       +
                     "type": "string",

     

       33
       +
                     "description": "Short commit hash"

     

       34
       +
                   },

     

       35
       +
                   "when": {

     

       36
       +
                     "type": "string",

     

       37
       +
                     "format": "datetime",

     

       38
       +
                     "description": "Timestamp of latest commit"

     

       39
       +
                   },

     

       40
       +
                   "message": {

     

       41
       +
                     "type": "string",

     

       42
       +
                     "description": "Latest commit message"

     

       43
       +
                   },

     

       44
       +
                   "author": {

     

       45
       +
                     "type": "ref",

     

       46
       +
                     "ref": "#signature"

     

       47
       +
                   }

     

       48
       +
                 }

     

       49
       +
               }

     

       50
       +
             },

     

       51
       +
             "errors": [

     

       52
       +
               {

     

       53
       +
                 "name": "RepoNotFound",

     

       54
       +
                 "description": "Repository not found or access denied"

     

       55
       +
               },

     

       56
       +
               {

     

       57
       +
                 "name": "InvalidRequest",

     

       58
       +
                 "description": "Invalid request parameters"

     

       59
       +
               }

     

       60
       +
             ]

     

       61
       +
           },

     

       62
       +
           "signature": {

     

       63
       +
             "type": "object",

     

       64
       +
             "required": ["name", "email", "when"],

     

       65
       +
             "properties": {

     

       66
       +
               "name": {

     

       67
       +
                 "type": "string",

     

       68
       +
                 "description": "Author name"

     

       69
       +
               },

     

       70
       +
               "email": {

     

       71
       +
                 "type": "string",

     

       72
       +
                 "description": "Author email"

     

       73
       +
               },

     

       74
       +
               "when": {

     

       75
       +
                 "type": "string",

     

       76
       +
                 "format": "datetime",

     

       77
       +
                 "description": "Author timestamp"

     

       78
       +
               }

     

       79
       +
             }

     

       80
       +
           }

     

       81
       +
         }

     

       82
       +
       }

+99

lexicons/repo/languages.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.languages",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "ref": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Git reference (branch, tag, or commit SHA)",

     

       18
       +
                   "default": "HEAD"

     

       19
       +
                 }

     

       20
       +
               }

     

       21
       +
             },

     

       22
       +
             "output": {

     

       23
       +
               "encoding": "application/json",

     

       24
       +
               "schema": {

     

       25
       +
                 "type": "object",

     

       26
       +
                 "required": ["ref", "languages"],

     

       27
       +
                 "properties": {

     

       28
       +
                   "ref": {

     

       29
       +
                     "type": "string",

     

       30
       +
                     "description": "The git reference used"

     

       31
       +
                   },

     

       32
       +
                   "languages": {

     

       33
       +
                     "type": "array",

     

       34
       +
                     "items": {

     

       35
       +
                       "type": "ref",

     

       36
       +
                       "ref": "#language"

     

       37
       +
                     }

     

       38
       +
                   },

     

       39
       +
                   "totalSize": {

     

       40
       +
                     "type": "integer",

     

       41
       +
                     "description": "Total size of all analyzed files in bytes"

     

       42
       +
                   },

     

       43
       +
                   "totalFiles": {

     

       44
       +
                     "type": "integer",

     

       45
       +
                     "description": "Total number of files analyzed"

     

       46
       +
                   }

     

       47
       +
                 }

     

       48
       +
               }

     

       49
       +
             },

     

       50
       +
             "errors": [

     

       51
       +
               {

     

       52
       +
                 "name": "RepoNotFound",

     

       53
       +
                 "description": "Repository not found or access denied"

     

       54
       +
               },

     

       55
       +
               {

     

       56
       +
                 "name": "RefNotFound",

     

       57
       +
                 "description": "Git reference not found"

     

       58
       +
               },

     

       59
       +
               {

     

       60
       +
                 "name": "InvalidRequest",

     

       61
       +
                 "description": "Invalid request parameters"

     

       62
       +
               }

     

       63
       +
             ]

     

       64
       +
           },

     

       65
       +
           "language": {

     

       66
       +
             "type": "object",

     

       67
       +
             "required": ["name", "size", "percentage"],

     

       68
       +
             "properties": {

     

       69
       +
               "name": {

     

       70
       +
                 "type": "string",

     

       71
       +
                 "description": "Programming language name"

     

       72
       +
               },

     

       73
       +
               "size": {

     

       74
       +
                 "type": "integer",

     

       75
       +
                 "description": "Total size of files in this language (bytes)"

     

       76
       +
               },

     

       77
       +
               "percentage": {

     

       78
       +
                 "type": "integer",

     

       79
       +
                 "description": "Percentage of total codebase (0-100)"

     

       80
       +
               },

     

       81
       +
               "fileCount": {

     

       82
       +
                 "type": "integer",

     

       83
       +
                 "description": "Number of files in this language"

     

       84
       +
               },

     

       85
       +
               "color": {

     

       86
       +
                 "type": "string",

     

       87
       +
                 "description": "Hex color code for this language"

     

       88
       +
               },

     

       89
       +
               "extensions": {

     

       90
       +
                 "type": "array",

     

       91
       +
                 "items": {

     

       92
       +
                   "type": "string"

     

       93
       +
                 },

     

       94
       +
                 "description": "File extensions associated with this language"

     

       95
       +
               }

     

       96
       +
             }

     

       97
       +
           }

     

       98
       +
         }

     

       99
       +
       }

+60

lexicons/repo/log.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.log",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo", "ref"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "ref": {

     

       16
       +
                   "type": "string",

     

       17
       +
                   "description": "Git reference (branch, tag, or commit SHA)"

     

       18
       +
                 },

     

       19
       +
                 "path": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "description": "Path to filter commits by",

     

       22
       +
                   "default": ""

     

       23
       +
                 },

     

       24
       +
                 "limit": {

     

       25
       +
                   "type": "integer",

     

       26
       +
                   "description": "Maximum number of commits to return",

     

       27
       +
                   "minimum": 1,

     

       28
       +
                   "maximum": 100,

     

       29
       +
                   "default": 50

     

       30
       +
                 },

     

       31
       +
                 "cursor": {

     

       32
       +
                   "type": "string",

     

       33
       +
                   "description": "Pagination cursor (commit SHA)"

     

       34
       +
                 }

     

       35
       +
               }

     

       36
       +
             },

     

       37
       +
             "output": {

     

       38
       +
               "encoding": "*/*"

     

       39
       +
             },

     

       40
       +
             "errors": [

     

       41
       +
               {

     

       42
       +
                 "name": "RepoNotFound",

     

       43
       +
                 "description": "Repository not found or access denied"

     

       44
       +
               },

     

       45
       +
               {

     

       46
       +
                 "name": "RefNotFound",

     

       47
       +
                 "description": "Git reference not found"

     

       48
       +
               },

     

       49
       +
               {

     

       50
       +
                 "name": "PathNotFound",

     

       51
       +
                 "description": "Path not found in repository"

     

       52
       +
               },

     

       53
       +
               {

     

       54
       +
                 "name": "InvalidRequest",

     

       55
       +
                 "description": "Invalid request parameters"

     

       56
       +
               }

     

       57
       +
             ]

     

       58
       +
           }

     

       59
       +
         }

     

       60
       +
       }

+43

lexicons/repo/tags.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.repo.tags",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "parameters": {

     

       8
       +
               "type": "params",

     

       9
       +
               "required": ["repo"],

     

       10
       +
               "properties": {

     

       11
       +
                 "repo": {

     

       12
       +
                   "type": "string",

     

       13
       +
                   "description": "Repository identifier in format 'did:plc:.../repoName'"

     

       14
       +
                 },

     

       15
       +
                 "limit": {

     

       16
       +
                   "type": "integer",

     

       17
       +
                   "description": "Maximum number of tags to return",

     

       18
       +
                   "minimum": 1,

     

       19
       +
                   "maximum": 100,

     

       20
       +
                   "default": 50

     

       21
       +
                 },

     

       22
       +
                 "cursor": {

     

       23
       +
                   "type": "string",

     

       24
       +
                   "description": "Pagination cursor"

     

       25
       +
                 }

     

       26
       +
               }

     

       27
       +
             },

     

       28
       +
             "output": {

     

       29
       +
               "encoding": "*/*"

     

       30
       +
             },

     

       31
       +
             "errors": [

     

       32
       +
               {

     

       33
       +
                 "name": "RepoNotFound",

     

       34
       +
                 "description": "Repository not found or access denied"

     

       35
       +
               },

     

       36
       +
               {

     

       37
       +
                 "name": "InvalidRequest",

     

       38
       +
                 "description": "Invalid request parameters"

     

       39
       +
               }

     

       40
       +
             ]

     

       41
       +
           }

     

       42
       +
         }

     

       43
       +
       }

-285

knotclient/unsigned.go

···

       1
       -
       package knotclient

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"bytes"

     

       5
       -
       	"encoding/json"

     

       6
       -
       	"fmt"

     

       7
       -
       	"io"

     

       8
       -
       	"log"

     

       9
       -
       	"net/http"

     

       10
       -
       	"net/url"

     

       11
       -
       	"strconv"

     

       12
       -
       	"time"

     

       13
       -
       

     

       14
       -
       	"tangled.sh/tangled.sh/core/types"

     

       15
       -
       )

     

       16
       -
       

     

       17
       -
       type UnsignedClient struct {

     

       18
       -
       	Url    *url.URL

     

       19
       -
       	client *http.Client

     

       20
       -
       }

     

       21
       -
       

     

       22
       -
       func NewUnsignedClient(domain string, dev bool) (*UnsignedClient, error) {

     

       23
       -
       	client := &http.Client{

     

       24
       -
       		Timeout: 5 * time.Second,

     

       25
       -
       	}

     

       26
       -
       

     

       27
       -
       	scheme := "https"

     

       28
       -
       	if dev {

     

       29
       -
       		scheme = "http"

     

       30
       -
       	}

     

       31
       -
       	url, err := url.Parse(fmt.Sprintf("%s://%s", scheme, domain))

     

       32
       -
       	if err != nil {

     

       33
       -
       		return nil, err

     

       34
       -
       	}

     

       35
       -
       

     

       36
       -
       	unsignedClient := &UnsignedClient{

     

       37
       -
       		client: client,

     

       38
       -
       		Url:    url,

     

       39
       -
       	}

     

       40
       -
       

     

       41
       -
       	return unsignedClient, nil

     

       42
       -
       }

     

       43
       -
       

     

       44
       -
       func (us *UnsignedClient) newRequest(method, endpoint string, query url.Values, body []byte) (*http.Request, error) {

     

       45
       -
       	reqUrl := us.Url.JoinPath(endpoint)

     

       46
       -
       

     

       47
       -
       	// add query parameters

     

       48
       -
       	if query != nil {

     

       49
       -
       		reqUrl.RawQuery = query.Encode()

     

       50
       -
       	}

     

       51
       -
       

     

       52
       -
       	return http.NewRequest(method, reqUrl.String(), bytes.NewReader(body))

     

       53
       -
       }

     

       54
       -
       

     

       55
       -
       func do[T any](us *UnsignedClient, req *http.Request) (*T, error) {

     

       56
       -
       	resp, err := us.client.Do(req)

     

       57
       -
       	if err != nil {

     

       58
       -
       		return nil, err

     

       59
       -
       	}

     

       60
       -
       	defer resp.Body.Close()

     

       61
       -
       

     

       62
       -
       	body, err := io.ReadAll(resp.Body)

     

       63
       -
       	if err != nil {

     

       64
       -
       		log.Printf("Error reading response body: %v", err)

     

       65
       -
       		return nil, err

     

       66
       -
       	}

     

       67
       -
       

     

       68
       -
       	var result T

     

       69
       -
       	err = json.Unmarshal(body, &result)

     

       70
       -
       	if err != nil {

     

       71
       -
       		log.Printf("Error unmarshalling response body: %v", err)

     

       72
       -
       		return nil, err

     

       73
       -
       	}

     

       74
       -
       

     

       75
       -
       	return &result, nil

     

       76
       -
       }

     

       77
       -
       

     

       78
       -
       func (us *UnsignedClient) Index(ownerDid, repoName, ref string) (*types.RepoIndexResponse, error) {

     

       79
       -
       	const (

     

       80
       -
       		Method = "GET"

     

       81
       -
       	)

     

       82
       -
       

     

       83
       -
       	endpoint := fmt.Sprintf("/%s/%s/tree/%s", ownerDid, repoName, ref)

     

       84
       -
       	if ref == "" {

     

       85
       -
       		endpoint = fmt.Sprintf("/%s/%s", ownerDid, repoName)

     

       86
       -
       	}

     

       87
       -
       

     

       88
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       89
       -
       	if err != nil {

     

       90
       -
       		return nil, err

     

       91
       -
       	}

     

       92
       -
       

     

       93
       -
       	return do[types.RepoIndexResponse](us, req)

     

       94
       -
       }

     

       95
       -
       

     

       96
       -
       func (us *UnsignedClient) Log(ownerDid, repoName, ref string, page int) (*types.RepoLogResponse, error) {

     

       97
       -
       	const (

     

       98
       -
       		Method = "GET"

     

       99
       -
       	)

     

       100
       -
       

     

       101
       -
       	endpoint := fmt.Sprintf("/%s/%s/log/%s", ownerDid, repoName, url.PathEscape(ref))

     

       102
       -
       

     

       103
       -
       	query := url.Values{}

     

       104
       -
       	query.Add("page", strconv.Itoa(page))

     

       105
       -
       	query.Add("per_page", strconv.Itoa(60))

     

       106
       -
       

     

       107
       -
       	req, err := us.newRequest(Method, endpoint, query, nil)

     

       108
       -
       	if err != nil {

     

       109
       -
       		return nil, err

     

       110
       -
       	}

     

       111
       -
       

     

       112
       -
       	return do[types.RepoLogResponse](us, req)

     

       113
       -
       }

     

       114
       -
       

     

       115
       -
       func (us *UnsignedClient) Branches(ownerDid, repoName string) (*types.RepoBranchesResponse, error) {

     

       116
       -
       	const (

     

       117
       -
       		Method = "GET"

     

       118
       -
       	)

     

       119
       -
       

     

       120
       -
       	endpoint := fmt.Sprintf("/%s/%s/branches", ownerDid, repoName)

     

       121
       -
       

     

       122
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       123
       -
       	if err != nil {

     

       124
       -
       		return nil, err

     

       125
       -
       	}

     

       126
       -
       

     

       127
       -
       	return do[types.RepoBranchesResponse](us, req)

     

       128
       -
       }

     

       129
       -
       

     

       130
       -
       func (us *UnsignedClient) Tags(ownerDid, repoName string) (*types.RepoTagsResponse, error) {

     

       131
       -
       	const (

     

       132
       -
       		Method = "GET"

     

       133
       -
       	)

     

       134
       -
       

     

       135
       -
       	endpoint := fmt.Sprintf("/%s/%s/tags", ownerDid, repoName)

     

       136
       -
       

     

       137
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       138
       -
       	if err != nil {

     

       139
       -
       		return nil, err

     

       140
       -
       	}

     

       141
       -
       

     

       142
       -
       	return do[types.RepoTagsResponse](us, req)

     

       143
       -
       }

     

       144
       -
       

     

       145
       -
       func (us *UnsignedClient) Branch(ownerDid, repoName, branch string) (*types.RepoBranchResponse, error) {

     

       146
       -
       	const (

     

       147
       -
       		Method = "GET"

     

       148
       -
       	)

     

       149
       -
       

     

       150
       -
       	endpoint := fmt.Sprintf("/%s/%s/branches/%s", ownerDid, repoName, url.PathEscape(branch))

     

       151
       -
       

     

       152
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       153
       -
       	if err != nil {

     

       154
       -
       		return nil, err

     

       155
       -
       	}

     

       156
       -
       

     

       157
       -
       	return do[types.RepoBranchResponse](us, req)

     

       158
       -
       }

     

       159
       -
       

     

       160
       -
       func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*types.RepoDefaultBranchResponse, error) {

     

       161
       -
       	const (

     

       162
       -
       		Method = "GET"

     

       163
       -
       	)

     

       164
       -
       

     

       165
       -
       	endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName)

     

       166
       -
       

     

       167
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       168
       -
       	if err != nil {

     

       169
       -
       		return nil, err

     

       170
       -
       	}

     

       171
       -
       

     

       172
       -
       	resp, err := us.client.Do(req)

     

       173
       -
       	if err != nil {

     

       174
       -
       		return nil, err

     

       175
       -
       	}

     

       176
       -
       	defer resp.Body.Close()

     

       177
       -
       

     

       178
       -
       	var defaultBranch types.RepoDefaultBranchResponse

     

       179
       -
       	if err := json.NewDecoder(resp.Body).Decode(&defaultBranch); err != nil {

     

       180
       -
       		return nil, err

     

       181
       -
       	}

     

       182
       -
       

     

       183
       -
       	return &defaultBranch, nil

     

       184
       -
       }

     

       185
       -
       

     

       186
       -
       func (us *UnsignedClient) Capabilities() (*types.Capabilities, error) {

     

       187
       -
       	const (

     

       188
       -
       		Method   = "GET"

     

       189
       -
       		Endpoint = "/capabilities"

     

       190
       -
       	)

     

       191
       -
       

     

       192
       -
       	req, err := us.newRequest(Method, Endpoint, nil, nil)

     

       193
       -
       	if err != nil {

     

       194
       -
       		return nil, err

     

       195
       -
       	}

     

       196
       -
       

     

       197
       -
       	resp, err := us.client.Do(req)

     

       198
       -
       	if err != nil {

     

       199
       -
       		return nil, err

     

       200
       -
       	}

     

       201
       -
       	defer resp.Body.Close()

     

       202
       -
       

     

       203
       -
       	var capabilities types.Capabilities

     

       204
       -
       	if err := json.NewDecoder(resp.Body).Decode(&capabilities); err != nil {

     

       205
       -
       		return nil, err

     

       206
       -
       	}

     

       207
       -
       

     

       208
       -
       	return &capabilities, nil

     

       209
       -
       }

     

       210
       -
       

     

       211
       -
       func (us *UnsignedClient) Compare(ownerDid, repoName, rev1, rev2 string) (*types.RepoFormatPatchResponse, error) {

     

       212
       -
       	const (

     

       213
       -
       		Method = "GET"

     

       214
       -
       	)

     

       215
       -
       

     

       216
       -
       	endpoint := fmt.Sprintf("/%s/%s/compare/%s/%s", ownerDid, repoName, url.PathEscape(rev1), url.PathEscape(rev2))

     

       217
       -
       

     

       218
       -
       	req, err := us.newRequest(Method, endpoint, nil, nil)

     

       219
       -
       	if err != nil {

     

       220
       -
       		return nil, fmt.Errorf("Failed to create request.")

     

       221
       -
       	}

     

       222
       -
       

     

       223
       -
       	compareResp, err := us.client.Do(req)

     

       224
       -
       	if err != nil {

     

       225
       -
       		return nil, fmt.Errorf("Failed to create request.")

     

       226
       -
       	}

     

       227
       -
       	defer compareResp.Body.Close()

     

       228
       -
       

     

       229
       -
       	switch compareResp.StatusCode {

     

       230
       -
       	case 404:

     

       231
       -
       	case 400:

     

       232
       -
       		return nil, fmt.Errorf("Branch comparisons not supported on this knot.")

     

       233
       -
       	}

     

       234
       -
       

     

       235
       -
       	respBody, err := io.ReadAll(compareResp.Body)

     

       236
       -
       	if err != nil {

     

       237
       -
       		log.Println("failed to compare across branches")

     

       238
       -
       		return nil, fmt.Errorf("Failed to compare branches.")

     

       239
       -
       	}

     

       240
       -
       	defer compareResp.Body.Close()

     

       241
       -
       

     

       242
       -
       	var formatPatchResponse types.RepoFormatPatchResponse

     

       243
       -
       	err = json.Unmarshal(respBody, &formatPatchResponse)

     

       244
       -
       	if err != nil {

     

       245
       -
       		log.Println("failed to unmarshal format-patch response", err)

     

       246
       -
       		return nil, fmt.Errorf("failed to compare branches.")

     

       247
       -
       	}

     

       248
       -
       

     

       249
       -
       	return &formatPatchResponse, nil

     

       250
       -
       }

     

       251
       -
       

     

       252
       -
       func (s *UnsignedClient) RepoLanguages(ownerDid, repoName, ref string) (*types.RepoLanguageResponse, error) {

     

       253
       -
       	const (

     

       254
       -
       		Method = "GET"

     

       255
       -
       	)

     

       256
       -
       	endpoint := fmt.Sprintf("/%s/%s/languages/%s", ownerDid, repoName, url.PathEscape(ref))

     

       257
       -
       

     

       258
       -
       	req, err := s.newRequest(Method, endpoint, nil, nil)

     

       259
       -
       	if err != nil {

     

       260
       -
       		return nil, err

     

       261
       -
       	}

     

       262
       -
       

     

       263
       -
       	resp, err := s.client.Do(req)

     

       264
       -
       	if err != nil {

     

       265
       -
       		return nil, err

     

       266
       -
       	}

     

       267
       -
       

     

       268
       -
       	var result types.RepoLanguageResponse

     

       269
       -
       	if resp.StatusCode != http.StatusOK {

     

       270
       -
       		log.Println("failed to calculate languages", resp.Status)

     

       271
       -
       		return &types.RepoLanguageResponse{}, nil

     

       272
       -
       	}

     

       273
       -
       

     

       274
       -
       	body, err := io.ReadAll(resp.Body)

     

       275
       -
       	if err != nil {

     

       276
       -
       		return nil, err

     

       277
       -
       	}

     

       278
       -
       

     

       279
       -
       	err = json.Unmarshal(body, &result)

     

       280
       -
       	if err != nil {

     

       281
       -
       		return nil, err

     

       282
       -
       	}

     

       283
       -
       

     

       284
       -
       	return &result, nil

     

       285
       -
       }

+2 -2

knotserver/events.go

···

       15
        
       	WriteBufferSize: 1024,

     

       16
        
       }

     

       17
        
       

     

       18
       -
       func (h *Handle) Events(w http.ResponseWriter, r *http.Request) {

     

       19
        
       	l := h.l.With("handler", "OpLog")

     

       20
        
       	l.Debug("received new connection")

     

       21
        
       

     
···

       83
        
       	}

     

       84
        
       }

     

       85
        
       

     

       86
       -
       func (h *Handle) streamOps(conn *websocket.Conn, cursor *int64) error {

     

       87
        
       	events, err := h.db.GetEvents(*cursor)

     

       88
        
       	if err != nil {

     

       89
        
       		h.l.Error("failed to fetch events from db", "err", err, "cursor", cursor)

···

       15
        
       	WriteBufferSize: 1024,

     

       16
        
       }

     

       17
        
       

     

       18
       +
       func (h *Knot) Events(w http.ResponseWriter, r *http.Request) {

     

       19
        
       	l := h.l.With("handler", "OpLog")

     

       20
        
       	l.Debug("received new connection")

     

       21
        
       

     
···

       83
        
       	}

     

       84
        
       }

     

       85
        
       

     

       86
       +
       func (h *Knot) streamOps(conn *websocket.Conn, cursor *int64) error {

     

       87
        
       	events, err := h.db.GetEvents(*cursor)

     

       88
        
       	if err != nil {

     

       89
        
       		h.l.Error("failed to fetch events from db", "err", err, "cursor", cursor)

+30

api/tangled/tangledowner.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.owner

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	OwnerNSID = "sh.tangled.owner"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // Owner_Output is the output of a sh.tangled.owner call.

     

       18
       +
       type Owner_Output struct {

     

       19
       +
       	Owner string `json:"owner" cborgen:"owner"`

     

       20
       +
       }

     

       21
       +
       

     

       22
       +
       // Owner calls the XRPC method "sh.tangled.owner".

     

       23
       +
       func Owner(ctx context.Context, c util.LexClient) (*Owner_Output, error) {

     

       24
       +
       	var out Owner_Output

     

       25
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.owner", nil, nil, &out); err != nil {

     

       26
       +
       		return nil, err

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	return &out, nil

     

       30
       +
       }

+31

lexicons/owner.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.owner",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "description": "Get the owner of a service",

     

       8
       +
             "output": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "owner"

     

       14
       +
                 ],

     

       15
       +
                 "properties": {

     

       16
       +
                   "owner": {

     

       17
       +
                     "type": "string",

     

       18
       +
                     "format": "did"

     

       19
       +
                   }

     

       20
       +
                 }

     

       21
       +
               }

     

       22
       +
             },

     

       23
       +
             "errors": [

     

       24
       +
               {

     

       25
       +
                 "name": "OwnerNotFound",

     

       26
       +
                 "description": "Owner is not set for this service"

     

       27
       +
               }

     

       28
       +
             ]

     

       29
       +
           }

     

       30
       +
         }

     

       31
       +
       }

-12

appview/pages/templates/knots/fragments/bannerRequiresUpgrade.html

···

       1
       -
       {{ define "knots/fragments/bannerRequiresUpgrade" }}

     

       2
       -
       <div class="px-6 py-2">

     

       3
       -
         The following knots that you administer will have to be upgraded to be compatible with the latest version of Tangled:

     

       4
       -
         <ul class="list-disc mx-12 my-2">

     

       5
       -
           {{range $i, $r := .Registrations}}

     

       6
       -
           <li>{{ $r.Domain }}</li>

     

       7
       -
           {{ end }}

     

       8
       -
         </ul>

     

       9
       -
         Repositories hosted on these knots will not be accessible until upgraded.

     

       10
       -
         <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/migrations/knot-1.8.0.md">Click to read the upgrade guide</a>.

     

       11
       -
       </div>

     

       12
       -
       {{ end }}

+30

api/tangled/knotversion.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.knot.version

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"context"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       const (

     

       14
       +
       	KnotVersionNSID = "sh.tangled.knot.version"

     

       15
       +
       )

     

       16
       +
       

     

       17
       +
       // KnotVersion_Output is the output of a sh.tangled.knot.version call.

     

       18
       +
       type KnotVersion_Output struct {

     

       19
       +
       	Version string `json:"version" cborgen:"version"`

     

       20
       +
       }

     

       21
       +
       

     

       22
       +
       // KnotVersion calls the XRPC method "sh.tangled.knot.version".

     

       23
       +
       func KnotVersion(ctx context.Context, c util.LexClient) (*KnotVersion_Output, error) {

     

       24
       +
       	var out KnotVersion_Output

     

       25
       +
       	if err := c.LexDo(ctx, util.Query, "", "sh.tangled.knot.version", nil, nil, &out); err != nil {

     

       26
       +
       		return nil, err

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	return &out, nil

     

       30
       +
       }

+25

lexicons/knot/version.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.knot.version",

     

       4
       +
         "defs": {

     

       5
       +
           "main": {

     

       6
       +
             "type": "query",

     

       7
       +
             "description": "Get the version of a knot",

     

       8
       +
             "output": {

     

       9
       +
               "encoding": "application/json",

     

       10
       +
               "schema": {

     

       11
       +
                 "type": "object",

     

       12
       +
                 "required": [

     

       13
       +
                   "version"

     

       14
       +
                 ],

     

       15
       +
                 "properties": {

     

       16
       +
                   "version": {

     

       17
       +
                     "type": "string"

     

       18
       +
                   }

     

       19
       +
                 }

     

       20
       +
               }

     

       21
       +
             },

     

       22
       +
             "errors": []

     

       23
       +
           }

     

       24
       +
         }

     

       25
       +
       }

+6 -1

appview/pages/templates/spindles/fragments/spindleListing.html

···

       30
        
       {{ define "spindleRightSide" }}

     

       31
        
         <div id="right-side" class="flex gap-2">

     

       32
        
           {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2 text-sm" }}

     

       33
       -
           {{ if .Verified }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
             <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span>

     

       35
        
             {{ template "spindles/fragments/addMemberModal" . }}

     

       36
        
           {{ else }}

     

       37
        
             <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} unverified</span>

     

       38
        
             {{ block "spindleRetryButton" . }} {{ end }}

     

       39
        
           {{ end }}

     

       0
        
       
     

       40
        
           {{ block "spindleDeleteButton" . }} {{ end }}

     

       41
        
         </div>

     

       42
        
       {{ end }}

···

       30
        
       {{ define "spindleRightSide" }}

     

       31
        
         <div id="right-side" class="flex gap-2">

     

       32
        
           {{ $style := "px-2 py-1 rounded flex items-center flex-shrink-0 gap-2 text-sm" }}

     

       33
       +
       

     

       34
       +
           {{ if .NeedsUpgrade }}

     

       35
       +
             <span class="bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200 {{$style}}"> {{ i "shield-alert" "w-4 h-4" }} needs upgrade </span>

     

       36
       +
             {{ block "spindleRetryButton" . }} {{ end }}

     

       37
       +
           {{ else if .Verified }}

     

       38
        
             <span class="bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200 {{$style}}">{{ i "shield-check" "w-4 h-4" }} verified</span>

     

       39
        
             {{ template "spindles/fragments/addMemberModal" . }}

     

       40
        
           {{ else }}

     

       41
        
             <span class="bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200 {{$style}}">{{ i "shield-off" "w-4 h-4" }} unverified</span>

     

       42
        
             {{ block "spindleRetryButton" . }} {{ end }}

     

       43
        
           {{ end }}

     

       44
       +
       

     

       45
        
           {{ block "spindleDeleteButton" . }} {{ end }}

     

       46
        
         </div>

     

       47
        
       {{ end }}

+37 -45

appview/pages/templates/repo/issues/fragments/editIssueComment.html

···

       1
        
       {{ define "repo/issues/fragments/editIssueComment" }}

     

       2
       -
         {{ with .Comment }}

     

       3
       -
         <div id="comment-container-{{.CommentId}}">

     

       4
       -
           <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm flex-wrap">

     

       5
       -
             {{ $owner := didOrHandle $.LoggedInUser.Did $.LoggedInUser.Handle }}

     

       6
       -
             <a href="/{{ $owner }}" class="no-underline hover:underline">{{ $owner }}</a>

     

       0
        
       
     

       0
        
       
     

       7
        
       

     

       8
       -
             <!-- show user "hats" -->

     

       9
       -
             {{ $isIssueAuthor := eq .OwnerDid $.Issue.OwnerDid }}

     

       10
       -
             {{ if $isIssueAuthor }}

     

       11
       -
             <span class="before:content-['·']"></span>

     

       12
       -
               author

     

       13
       -
             {{ end }}

     

       14
       -
       

     

       15
       -
             <span class="before:content-['·']"></span>

     

       16
       -
             <a

     

       17
       -
                 href="#{{ .CommentId }}"

     

       18
       -
                 class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline"

     

       19
       -
                 id="{{ .CommentId }}">

     

       20
       -
               {{ template "repo/fragments/time" .Created }}

     

       21
       -
             </a>

     

       22
       -
       

     

       23
       -
             <button

     

       24
       -
               class="btn px-2 py-1 flex items-center gap-2 text-sm group"

     

       25
       -
               hx-post="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/edit"

     

       26
       -
               hx-include="#edit-textarea-{{ .CommentId }}"

     

       27
       -
               hx-target="#comment-container-{{ .CommentId }}"

     

       28
       -
               hx-swap="outerHTML">

     

       29
       -
               {{ i "check" "w-4 h-4" }}

     

       30
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       31
       -
             </button>

     

       32
       -
             <button

     

       33
       -
               class="btn px-2 py-1  flex items-center gap-2 text-sm"

     

       34
       -
               hx-get="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/"

     

       35
       -
               hx-target="#comment-container-{{ .CommentId }}"

     

       36
       -
               hx-swap="outerHTML">

     

       37
       -
               {{ i "x" "w-4 h-4" }}

     

       38
       -
             </button>

     

       39
       -
             <span id="comment-{{.CommentId}}-status"></span>

     

       40
       -
           </div>

     

       41
        
       

     

       42
       -
           <div>

     

       43
       -
             <textarea

     

       44
       -
               id="edit-textarea-{{ .CommentId }}"

     

       45
       -
               name="body"

     

       46
       -
               class="w-full p-2 border rounded min-h-[100px]">{{ .Body }}</textarea>

     

       47
       -
           </div>

     

       48
        
         </div>

     

       49
       -
         {{ end }}

     

       50
        
       {{ end }}

     

       51
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       {{ define "repo/issues/fragments/editIssueComment" }}

     

       2
       +
         <div id="comment-body-{{.Comment.Id}}" class="pt-2">

     

       3
       +
           <textarea

     

       4
       +
             id="edit-textarea-{{ .Comment.Id }}"

     

       5
       +
             name="body"

     

       6
       +
             class="w-full p-2 rounded border border-gray-200 dark:border-gray-700"

     

       7
       +
             rows="5"

     

       8
       +
             autofocus>{{ .Comment.Body }}</textarea>

     

       9
        
       

     

       10
       +
           {{ template "editActions" $ }}

     

       11
       +
         </div>

     

       12
       +
       {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       

     

       14
       +
       {{ define "editActions" }}

     

       15
       +
         <div class="flex flex-wrap items-center justify-end gap-2 text-gray-500 dark:text-gray-400 text-sm pt-2">

     

       16
       +
           {{ template "cancel" . }}

     

       17
       +
           {{ template "save" . }}

     

       0
        
       
     

       0
        
       
     

       18
        
         </div>

     

       0
        
       
     

       19
        
       {{ end }}

     

       20
        
       

     

       21
       +
       {{ define "save" }}

     

       22
       +
         <button

     

       23
       +
           class="btn-create py-0 flex gap-1 items-center group text-sm"

     

       24
       +
           hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/edit"

     

       25
       +
           hx-include="#edit-textarea-{{ .Comment.Id }}"

     

       26
       +
           hx-target="#comment-body-{{ .Comment.Id }}"

     

       27
       +
           hx-swap="outerHTML">

     

       28
       +
           {{ i "check" "size-4" }}

     

       29
       +
           save

     

       30
       +
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       31
       +
         </button>

     

       32
       +
       {{ end }}

     

       33
       +
       

     

       34
       +
       {{ define "cancel" }}

     

       35
       +
         <button

     

       36
       +
           class="btn py-0 text-red-500 dark:text-red-400 flex gap-1 items-center group"

     

       37
       +
           hx-get="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/comment/{{ .Comment.Id }}/"

     

       38
       +
           hx-target="#comment-body-{{ .Comment.Id }}"

     

       39
       +
           hx-swap="outerHTML">

     

       40
       +
           {{ i "x" "size-4" }}

     

       41
       +
           cancel

     

       42
       +
         </button>

     

       43
       +
       {{ end }}

-58

appview/pages/templates/repo/issues/fragments/issueComment.html

···

       1
       -
       {{ define "repo/issues/fragments/issueComment" }}

     

       2
       -
         {{ with .Comment }}

     

       3
       -
         <div id="comment-container-{{.CommentId}}">

     

       4
       -
           <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm flex-wrap">

     

       5
       -
             {{ template "user/fragments/picHandleLink" .OwnerDid }}

     

       6
       -
       

     

       7
       -
             <!-- show user "hats" -->

     

       8
       -
             {{ $isIssueAuthor := eq .OwnerDid $.Issue.OwnerDid }}

     

       9
       -
             {{ if $isIssueAuthor }}

     

       10
       -
               <span class="before:content-['·']"></span>

     

       11
       -
               author

     

       12
       -
             {{ end }}

     

       13
       -
       

     

       14
       -
            <span class="before:content-['·']"></span>

     

       15
       -
             <a

     

       16
       -
                 href="#{{ .CommentId }}"

     

       17
       -
                 class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-400 hover:underline no-underline"

     

       18
       -
                 id="{{ .CommentId }}">

     

       19
       -
               {{ if .Deleted }}

     

       20
       -
                 deleted {{ template "repo/fragments/time" .Deleted }}

     

       21
       -
               {{ else if .Edited }}

     

       22
       -
                 edited {{ template "repo/fragments/time" .Edited }}

     

       23
       -
               {{ else }}

     

       24
       -
                 {{ template "repo/fragments/time" .Created }}

     

       25
       -
               {{ end }}

     

       26
       -
             </a>

     

       27
       -
       

     

       28
       -
             {{ $isCommentOwner := and $.LoggedInUser (eq $.LoggedInUser.Did .OwnerDid) }}

     

       29
       -
             {{ if and $isCommentOwner (not .Deleted) }}

     

       30
       -
             <button

     

       31
       -
               class="btn px-2 py-1 text-sm"

     

       32
       -
               hx-get="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/edit"

     

       33
       -
               hx-swap="outerHTML"

     

       34
       -
               hx-target="#comment-container-{{.CommentId}}"

     

       35
       -
               >

     

       36
       -
               {{ i "pencil" "w-4 h-4" }}

     

       37
       -
             </button>

     

       38
       -
             <button

     

       39
       -
               class="btn px-2 py-1 text-sm text-red-500 flex gap-2 items-center group"

     

       40
       -
               hx-delete="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/"

     

       41
       -
               hx-confirm="Are you sure you want to delete your comment?"

     

       42
       -
               hx-swap="outerHTML"

     

       43
       -
               hx-target="#comment-container-{{.CommentId}}"

     

       44
       -
               >

     

       45
       -
               {{ i "trash-2" "w-4 h-4" }}

     

       46
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       47
       -
             </button>

     

       48
       -
             {{ end }}

     

       49
       -
       

     

       50
       -
           </div>

     

       51
       -
           {{ if not .Deleted }}

     

       52
       -
           <div class="prose dark:prose-invert">

     

       53
       -
             {{ .Body | markdown }}

     

       54
       -
           </div>

     

       55
       -
           {{ end }}

     

       56
       -
         </div>

     

       57
       -
         {{ end }}

     

       58
       -
       {{ end }}

appview/pages/templates/repo/issues/fragments/issueCommentBody.html

···

       1
       +
       {{ define "repo/issues/fragments/issueCommentBody" }}

     

       2
       +
       <div id="comment-body-{{.Comment.Id}}">

     

       3
       +
         {{ if not .Comment.Deleted }}

     

       4
       +
           <div class="prose dark:prose-invert">{{ .Comment.Body | markdown }}</div>

     

       5
       +
         {{ else }}

     

       6
       +
           <div class="prose dark:prose-invert italic text-gray-500 dark:text-gray-400">[deleted by author]</div>

     

       7
       +
         {{ end }}

     

       8
       +
       </div>

     

       9
       +
       {{ end }}

+57

appview/pages/templates/repo/issues/fragments/putIssue.html

···

       1
       +
       {{ define "repo/issues/fragments/putIssue" }}

     

       2
       +
       <!-- this form is used for new and edit, .Issue is passed when editing -->

     

       3
       +
       <form

     

       4
       +
         {{ if eq .Action "edit" }}

     

       5
       +
           hx-post="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}/edit"

     

       6
       +
         {{ else }}

     

       7
       +
           hx-post="/{{ .RepoInfo.FullName }}/issues/new"

     

       8
       +
         {{ end }}

     

       9
       +
         hx-swap="none"

     

       10
       +
         hx-indicator="#spinner">

     

       11
       +
         <div class="flex flex-col gap-2">

     

       12
       +
           <div>

     

       13
       +
             <label for="title">title</label>

     

       14
       +
             <input type="text" name="title" id="title" class="w-full" value="{{ if .Issue }}{{ .Issue.Title }}{{ end }}" />

     

       15
       +
           </div>

     

       16
       +
           <div>

     

       17
       +
             <label for="body">body</label>

     

       18
       +
             <textarea

     

       19
       +
               name="body"

     

       20
       +
               id="body"

     

       21
       +
               rows="6"

     

       22
       +
               class="w-full resize-y"

     

       23
       +
               placeholder="Describe your issue. Markdown is supported."

     

       24
       +
               >{{ if .Issue }}{{ .Issue.Body }}{{ end }}</textarea>

     

       25
       +
           </div>

     

       26
       +
           <div class="flex justify-between">

     

       27
       +
             <div id="issues" class="error"></div>

     

       28
       +
             <div class="flex gap-2 items-center">

     

       29
       +
               <a 

     

       30
       +
                 class="btn flex items-center gap-2 no-underline hover:no-underline"

     

       31
       +
                 type="button"

     

       32
       +
                 {{ if .Issue }}

     

       33
       +
                   href="/{{ .RepoInfo.FullName }}/issues/{{ .Issue.IssueId }}"

     

       34
       +
                 {{ else }}

     

       35
       +
                   href="/{{ .RepoInfo.FullName }}/issues"

     

       36
       +
                 {{ end }}

     

       37
       +
                 >

     

       38
       +
                 {{ i "x" "w-4 h-4" }}

     

       39
       +
                 cancel

     

       40
       +
               </a>

     

       41
       +
               <button type="submit" class="btn-create flex items-center gap-2">

     

       42
       +
                 {{ if eq .Action "edit" }}

     

       43
       +
                   {{ i "pencil" "w-4 h-4" }}

     

       44
       +
                   {{ .Action }} issue

     

       45
       +
                 {{ else }}

     

       46
       +
                   {{ i "circle-plus" "w-4 h-4" }}

     

       47
       +
                   {{ .Action }} issue

     

       48
       +
                 {{ end }}

     

       49
       +
                 <span id="spinner" class="group">

     

       50
       +
                   {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       51
       +
                 </span>

     

       52
       +
               </button>

     

       53
       +
             </div>

     

       54
       +
           </div>

     

       55
       +
         </div>

     

       56
       +
       </form>

     

       57
       +
       {{ end }}

+1 -33

appview/pages/templates/repo/issues/new.html

···

       1
        
       {{ define "title" }}new issue &middot; {{ .RepoInfo.FullName }}{{ end }}

     

       2
        
       

     

       3
        
       {{ define "repoContent" }}

     

       4
       -
           <form

     

       5
       -
               hx-post="/{{ .RepoInfo.FullName }}/issues/new"

     

       6
       -
               class="space-y-6"

     

       7
       -
               hx-swap="none"

     

       8
       -
               hx-indicator="#spinner"

     

       9
       -
           >

     

       10
       -
               <div class="flex flex-col gap-4">

     

       11
       -
                   <div>

     

       12
       -
                       <label for="title">title</label>

     

       13
       -
                       <input type="text" name="title" id="title" class="w-full" />

     

       14
       -
                   </div>

     

       15
       -
                   <div>

     

       16
       -
                       <label for="body">body</label>

     

       17
       -
                       <textarea

     

       18
       -
                           name="body"

     

       19
       -
                           id="body"

     

       20
       -
                           rows="6"

     

       21
       -
                           class="w-full resize-y"

     

       22
       -
                           placeholder="Describe your issue. Markdown is supported."

     

       23
       -
                       ></textarea>

     

       24
       -
                   </div>

     

       25
       -
                   <div>

     

       26
       -
                       <button type="submit" class="btn-create flex items-center gap-2">

     

       27
       -
                           {{ i "circle-plus" "w-4 h-4" }}

     

       28
       -
                           create issue

     

       29
       -
                           <span id="spinner" class="group">

     

       30
       -
                               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       31
       -
                           </span>

     

       32
       -
                       </button>

     

       33
       -
                   </div>

     

       34
       -
               </div>

     

       35
       -
               <div id="issues" class="error"></div>

     

       36
       -
           </form>

     

       37
        
       {{ end }}

···

       1
        
       {{ define "title" }}new issue &middot; {{ .RepoInfo.FullName }}{{ end }}

     

       2
        
       

     

       3
        
       {{ define "repoContent" }}

     

       4
       +
         {{ template "repo/issues/fragments/putIssue" . }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       {{ end }}

+8 -2

nix/gomod2nix.toml

···

       425
        
         [mod."github.com/whyrusleeping/cbor-gen"]

     

       426
        
           version = "v0.3.1"

     

       427
        
           hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc="

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       428
        
         [mod."github.com/yuin/goldmark"]

     

       429
       -
           version = "v1.4.15"

     

       430
       -
           hash = "sha256-MvSOT6dwf5hVYkIg4MnqMpsy5ZtWZ7amAE7Zo9HkEa0="

     

       431
        
         [mod."github.com/yuin/goldmark-highlighting/v2"]

     

       432
        
           version = "v2.0.0-20230729083705-37449abec8cc"

     

       433
        
           hash = "sha256-HpiwU7jIeDUAg2zOpTIiviQir8dpRPuXYh2nqFFccpg="

···

       425
        
         [mod."github.com/whyrusleeping/cbor-gen"]

     

       426
        
           version = "v0.3.1"

     

       427
        
           hash = "sha256-PAd8M2Z8t6rVRBII+Rg8Bz+QaJIwbW64bfyqsv31kgc="

     

       428
       +
         [mod."github.com/wyatt915/goldmark-treeblood"]

     

       429
       +
           version = "v0.0.0-20250825231212-5dcbdb2f4b57"

     

       430
       +
           hash = "sha256-IZEsUXTBTsNgWoD7vqRUc9aFCCHNjzk1IUmI9O+NCnM="

     

       431
       +
         [mod."github.com/wyatt915/treeblood"]

     

       432
       +
           version = "v0.1.15"

     

       433
       +
           hash = "sha256-hb99exdkoY2Qv8WdDxhwgPXGbEYimUr6wFtPXEvcO9g="

     

       434
        
         [mod."github.com/yuin/goldmark"]

     

       435
       +
           version = "v1.7.12"

     

       436
       +
           hash = "sha256-thLYBS4woL2X5qRdo7vP+xCvjlGRDU0jXtDCUt6vvWM="

     

       437
        
         [mod."github.com/yuin/goldmark-highlighting/v2"]

     

       438
        
           version = "v2.0.0-20230729083705-37449abec8cc"

     

       439
        
           hash = "sha256-HpiwU7jIeDUAg2zOpTIiviQir8dpRPuXYh2nqFFccpg="

xrpc/errors/errors.go

···

       61
        
       	WithMessage("failed to access repository"),

     

       62
        
       )

     

       63
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64
        
       var AuthError = func(err error) XrpcError {

     

       65
        
       	return NewXrpcError(

     

       66
        
       		WithTag("Auth"),

···

       61
        
       	WithMessage("failed to access repository"),

     

       62
        
       )

     

       63
        
       

     

       64
       +
       var RefNotFoundError = NewXrpcError(

     

       65
       +
       	WithTag("RefNotFound"),

     

       66
       +
       	WithMessage("failed to access ref"),

     

       67
       +
       )

     

       68
       +
       

     

       69
        
       var AuthError = func(err error) XrpcError {

     

       70
        
       	return NewXrpcError(

     

       71
        
       		WithTag("Auth"),

+15

flake.lock

···

       1
        
       {

     

       2
        
         "nodes": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3
        
           "flake-utils": {

     

       4
        
             "inputs": {

     

       5
        
               "systems": "systems"

     
···

       136
        
           },

     

       137
        
           "root": {

     

       138
        
             "inputs": {

     

       0
        
       
     

       139
        
               "gomod2nix": "gomod2nix",

     

       140
        
               "htmx-src": "htmx-src",

     

       141
        
               "htmx-ws-src": "htmx-ws-src",

···

       1
        
       {

     

       2
        
         "nodes": {

     

       3
       +
           "flake-compat": {

     

       4
       +
             "flake": false,

     

       5
       +
             "locked": {

     

       6
       +
               "lastModified": 1751685974,

     

       7
       +
               "narHash": "sha256-NKw96t+BgHIYzHUjkTK95FqYRVKB8DHpVhefWSz/kTw=",

     

       8
       +
               "rev": "549f2762aebeff29a2e5ece7a7dc0f955281a1d1",

     

       9
       +
               "type": "tarball",

     

       10
       +
               "url": "https://git.lix.systems/api/v1/repos/lix-project/flake-compat/archive/549f2762aebeff29a2e5ece7a7dc0f955281a1d1.tar.gz?rev=549f2762aebeff29a2e5ece7a7dc0f955281a1d1"

     

       11
       +
             },

     

       12
       +
             "original": {

     

       13
       +
               "type": "tarball",

     

       14
       +
               "url": "https://git.lix.systems/lix-project/flake-compat/archive/main.tar.gz"

     

       15
       +
             }

     

       16
       +
           },

     

       17
        
           "flake-utils": {

     

       18
        
             "inputs": {

     

       19
        
               "systems": "systems"

     
···

       150
        
           },

     

       151
        
           "root": {

     

       152
        
             "inputs": {

     

       153
       +
               "flake-compat": "flake-compat",

     

       154
        
               "gomod2nix": "gomod2nix",

     

       155
        
               "htmx-src": "htmx-src",

     

       156
        
               "htmx-ws-src": "htmx-ws-src",

+44

contrib/Tiltfile

···

       1
       +
       common_env = {

     

       2
       +
           "TANGLED_VM_SPINDLE_OWNER": os.getenv("TANGLED_VM_SPINDLE_OWNER", default=""),

     

       3
       +
           "TANGLED_VM_KNOT_OWNER": os.getenv("TANGLED_VM_KNOT_OWNER", default=""),

     

       4
       +
           "TANGLED_DB_PATH": os.getenv("TANGLED_DB_PATH", default="dev.db"),

     

       5
       +
           "TANGLED_DEV": os.getenv("TANGLED_DEV", default="true"),

     

       6
       +
       }

     

       7
       +
       

     

       8
       +
       nix_globs = ["nix/**", "flake.nix", "flake.lock"]

     

       9
       +
       

     

       10
       +
       local_resource(

     

       11
       +
           name="appview",

     

       12
       +
           serve_cmd="nix run .#watch-appview",

     

       13
       +
           serve_dir="..",

     

       14
       +
           deps=nix_globs,

     

       15
       +
           env=common_env,

     

       16
       +
           allow_parallel=True,

     

       17
       +
       )

     

       18
       +
       

     

       19
       +
       local_resource(

     

       20
       +
           name="tailwind",

     

       21
       +
           serve_cmd="nix run .#watch-tailwind",

     

       22
       +
           serve_dir="..",

     

       23
       +
           deps=nix_globs,

     

       24
       +
           env=common_env,

     

       25
       +
           allow_parallel=True,

     

       26
       +
       )

     

       27
       +
       

     

       28
       +
       local_resource(

     

       29
       +
           name="redis",

     

       30
       +
           serve_cmd="redis-server",

     

       31
       +
           serve_dir="..",

     

       32
       +
           deps=nix_globs,

     

       33
       +
           env=common_env,

     

       34
       +
           allow_parallel=True,

     

       35
       +
       )

     

       36
       +
       

     

       37
       +
       local_resource(

     

       38
       +
           name="vm",

     

       39
       +
           serve_cmd="nix run --impure .#vm",

     

       40
       +
           serve_dir="..",

     

       41
       +
           deps=nix_globs,

     

       42
       +
           env=common_env,

     

       43
       +
           allow_parallel=True,

     

       44
       +
       )

flake.nix

···

       151
        
               nativeBuildInputs = [

     

       152
        
                 pkgs.go

     

       153
        
                 pkgs.air

     

       0
        
       
     

       154
        
                 pkgs.gopls

     

       155
        
                 pkgs.httpie

     

       156
        
                 pkgs.litecli

···

       151
        
               nativeBuildInputs = [

     

       152
        
                 pkgs.go

     

       153
        
                 pkgs.air

     

       154
       +
                 pkgs.tilt

     

       155
        
                 pkgs.gopls

     

       156
        
                 pkgs.httpie

     

       157
        
                 pkgs.litecli

+90

appview/pages/templates/fragments/multiline-select.html

···

       1
       +
       {{ define "fragments/multiline-select" }}

     

       2
       +
         <script>

     

       3
       +
           function highlight(scroll = false) {

     

       4
       +
             document.querySelectorAll(".hl").forEach(el => {

     

       5
       +
               el.classList.remove("hl");

     

       6
       +
             });

     

       7
       +
       

     

       8
       +
             const hash = window.location.hash;

     

       9
       +
             if (!hash || !hash.startsWith("#L")) {

     

       10
       +
               return;

     

       11
       +
             }

     

       12
       +
       

     

       13
       +
             const rangeStr = hash.substring(2);

     

       14
       +
             const parts = rangeStr.split("-");

     

       15
       +
             let startLine, endLine;

     

       16
       +
       

     

       17
       +
             if (parts.length === 2) {

     

       18
       +
               startLine = parseInt(parts[0], 10);

     

       19
       +
               endLine = parseInt(parts[1], 10);

     

       20
       +
             } else {

     

       21
       +
               startLine = parseInt(parts[0], 10);

     

       22
       +
               endLine = startLine;

     

       23
       +
             }

     

       24
       +
       

     

       25
       +
             if (isNaN(startLine) || isNaN(endLine)) {

     

       26
       +
               console.log("nan");

     

       27
       +
               console.log(startLine);

     

       28
       +
               console.log(endLine);

     

       29
       +
               return;

     

       30
       +
             }

     

       31
       +
       

     

       32
       +
             let target = null;

     

       33
       +
       

     

       34
       +
             for (let i = startLine; i<= endLine; i++) {

     

       35
       +
               const idEl = document.getElementById(`L${i}`);

     

       36
       +
               if (idEl) {

     

       37
       +
                 const el = idEl.closest(".line");

     

       38
       +
                 if (el) {

     

       39
       +
                   el.classList.add("hl");

     

       40
       +
                   target = el;

     

       41
       +
                 }

     

       42
       +
               }

     

       43
       +
             }

     

       44
       +
       

     

       45
       +
             if (scroll && target) {

     

       46
       +
               target.scrollIntoView({

     

       47
       +
                 behavior: "smooth",

     

       48
       +
                 block: "center",

     

       49
       +
               });

     

       50
       +
             }

     

       51
       +
           }

     

       52
       +
       

     

       53
       +
           document.addEventListener("DOMContentLoaded", () => {

     

       54
       +
             console.log("DOMContentLoaded");

     

       55
       +
             highlight(true);

     

       56
       +
           });

     

       57
       +
           window.addEventListener("hashchange", () => {

     

       58
       +
             console.log("hashchange");

     

       59
       +
             highlight();

     

       60
       +
           });

     

       61
       +
           window.addEventListener("popstate", () => {

     

       62
       +
             console.log("popstate");

     

       63
       +
             highlight();

     

       64
       +
           });

     

       65
       +
       

     

       66
       +
           const lineNumbers = document.querySelectorAll('a[href^="#L"');

     

       67
       +
           let startLine = null;

     

       68
       +
       

     

       69
       +
           lineNumbers.forEach(el => {

     

       70
       +
             el.addEventListener("click", (event) => {

     

       71
       +
               event.preventDefault();

     

       72
       +
               const currentLine = parseInt(el.href.split("#L")[1]);

     

       73
       +
       

     

       74
       +
               if (event.shiftKey && startLine !== null) {

     

       75
       +
                 const endLine = currentLine;

     

       76
       +
                 const min = Math.min(startLine, endLine);

     

       77
       +
                 const max = Math.max(startLine, endLine);

     

       78
       +
                 const newHash = `#L${min}-${max}`;

     

       79
       +
                 history.pushState(null, '', newHash);

     

       80
       +
               } else {

     

       81
       +
                 const newHash = `#L${currentLine}`;

     

       82
       +
                 history.pushState(null, '', newHash);

     

       83
       +
                 startLine = currentLine;

     

       84
       +
               }

     

       85
       +
       

     

       86
       +
               highlight();

     

       87
       +
             });

     

       88
       +
           });

     

       89
       +
         </script>

     

       90
       +
       {{ end }}

+56

appview/pages/templates/fragments/dolly/logo.html

···

       1
       +
       {{ define "fragments/dolly/logo" }}

     

       2
       +
       <svg

     

       3
       +
          version="1.1"

     

       4
       +
          id="svg1"

     

       5
       +
          class="{{.}}"

     

       6
       +
          width="25"

     

       7
       +
          height="25"

     

       8
       +
          viewBox="0 0 25 25"

     

       9
       +
          sodipodi:docname="tangled_dolly_face_only.png"

     

       10
       +
          xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       11
       +
          xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       12
       +
          xmlns:xlink="http://www.w3.org/1999/xlink"

     

       13
       +
          xmlns="http://www.w3.org/2000/svg"

     

       14
       +
          xmlns:svg="http://www.w3.org/2000/svg">

     

       15
       +
         <title>Dolly</title>

     

       16
       +
         <defs

     

       17
       +
            id="defs1" />

     

       18
       +
         <sodipodi:namedview

     

       19
       +
            id="namedview1"

     

       20
       +
            pagecolor="#ffffff"

     

       21
       +
            bordercolor="#000000"

     

       22
       +
            borderopacity="0.25"

     

       23
       +
            inkscape:showpageshadow="2"

     

       24
       +
            inkscape:pageopacity="0.0"

     

       25
       +
            inkscape:pagecheckerboard="true"

     

       26
       +
            inkscape:deskcolor="#d5d5d5">

     

       27
       +
           <inkscape:page

     

       28
       +
              x="0"

     

       29
       +
              y="0"

     

       30
       +
              width="25"

     

       31
       +
              height="25"

     

       32
       +
              id="page2"

     

       33
       +
              margin="0"

     

       34
       +
              bleed="0" />

     

       35
       +
         </sodipodi:namedview>

     

       36
       +
         <g

     

       37
       +
            inkscape:groupmode="layer"

     

       38
       +
            inkscape:label="Image"

     

       39
       +
            id="g1">

     

       40
       +
           <image

     

       41
       +
              width="252.48"

     

       42
       +
              height="248.96001"

     

       43
       +
              preserveAspectRatio="none"

     

       44
       +
              xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAxUAAAMKCAYAAADznWlEAAABg2lDQ1BJQ0MgcHJvZmlsZQAAKJF9&#10;kT1Iw0AcxV9TpVoqDmYQcchQneyiIo61CkWoEGqFVh1MLv2CJi1Jiouj4Fpw8GOx6uDirKuDqyAI&#10;foC4C06KLlLi/5JCixgPjvvx7t7j7h0gNCtMt3rigG7YZjqZkLK5VSn0in6EISKGsMKs2pwsp+A7&#10;vu4R4OtdjGf5n/tzDGh5iwEBiTjOaqZNvEE8s2nXOO8Ti6ykaMTnxBMmXZD4keuqx2+ciy4LPFM0&#10;M+l5YpFYKnax2sWsZOrE08RRTTcoX8h6rHHe4qxX6qx9T/7CSN5YWeY6zVEksYglyJCgoo4yKrCp&#10;rzIMUiykaT/h4x9x/TK5VHKVwcixgCp0KK4f/A9+d2sVpia9pEgC6H1xnI8xILQLtBqO833sOK0T&#10;IPgMXBkdf7UJzH6S3uho0SNgcBu4uO5o6h5wuQMMP9UUU3GlIE2hUADez+ibcsDQLRBe83pr7+P0&#10;AchQV6kb4OAQGC9S9rrPu/u6e/v3TLu/H4tGcrDFxPPTAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBI&#10;WXMAAC4jAAAuIwF4pT92AAAAB3RJTUUH6QkPFQ8jl/6e6wAAABl0RVh0Q29tbWVudABDcmVhdGVk&#10;IHdpdGggR0lNUFeBDhcAACAASURBVHic7N3nc5xXmqb564UjCXoripShvKNMqVSSynWXmZ6emd39&#10;NhH7R+6HjdiN6d3emZ7uru6ukqpKXUbeUKIMJZKitwBhzn64z1uZpEiJIAGkea9fRAZIgCCTQCLz&#10;3O95nueAJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmSJEmS&#10;JEmSJEmSJEmSJEmSJOkONYO+A5IkjYtSSgNM0Ht9LX036vvbj7fvX+77K/pfl0vTNAVJGgGGCkmS&#10;vkUNCjRNU+qvG2ASmKpvJ+rb9n3T9e0EvTCx3Pfr/o8ttf9M/fVS/bOL9bbU97HlvrcT7d/bNE1/&#10;KJGkgTBUSJI6ry8stIGhDQhTwAwJCu1CfhrYCGwGZoENwCZgS9/7pkgAmKuf0+5QTNbPnagfu9L3&#10;7zYkMCwA54BL9deQYHGlvm+eXkBZrH/P1fpnl+mFj4K7HZLWiaFCktQpNUDcuMMwScLCDFn0tyFh&#10;K7Ctvt1Q/9yG+vsd9WNbgO319zvrxxrgInCaLO6n6t87S4JHA5ytN/o+PkMCwTHgDHCNXrg5A5yq&#10;f+9ivf9X6/tPA5dJ8Gjftrsd1+qt3eX4S8gwcEhaLYYKSdLYakuXqnY3YANZ2LeBoD88bCMBof/X&#10;2+vHZ+kFjvbX01y/s9H+GrKIX7zh327DzK0+PkEW/m0IKH0fu0hCROn7d88DJ+pbyA7HMeAreuHi&#10;PAkdZ4EL9e9u+zkWgCXDhaS7ZaiQJI2VvmbpdvehDQJtydJOYD9wD7CL3i5DGyTaALGJBJAN9Pok&#10;2tsk6/8a2u40tOGkIQGhLX1q6IWIy/XPXwC+Bo4DX5LAcY5e6dU5ElYuk7KqtsfDXQxJK2KokCSN&#10;tBuap2folS5tIWFhL7CHXnnSXmAfsJvrdyA2kgAxQy84jJq2vKkNVldIaDhHSqdOkL6Mufq+L0jg&#10;OFk/3n5sjoSMhaZplpCk72CokCSNnL7diP6m6V0kPOyhFyT2kV2JvVzfAzFLr4ToxtfCcXttbMfW&#10;zpOdjXac7QWye3GclEsdIyVS50j4OFH/zEUSMtpGcJu/JX3DuD1xSpLG1E12JNogcS9wCHgBeIIE&#10;ie314+3kprbXYYLeORFdew3sPy8DeqNr5+ntZiyR4PEZ8A4JHZ+R0HGalFbN1c9bBsukJEXXnlAl&#10;SSOmlNI/inUrCQy7gfuAB+vtAeBx0ifR9kBM3Ozv000tcf342kv0+i2OkHDxFfAB8DHZxbhcP+ea&#10;Z2VIMlRIkoZO3ZWYoje+dScJD48CB+mVNe2rH2snNU0P4v6OsWWyQ3GJlEZ9BLxFgsbx+rGv6fVi&#10;LLhzIXWToUKSNDRKKW1p0yzpgdhHQsQDwHPAs6TcqT03Ygpfy9bLItm9+JTsXHxZf/0JCRhfkzMz&#10;2gP6Ft3BkLrDJ2JJ0sDccJL1NNlx2E9CxEP19gBwgISLvSR0tH0RWl9L9EbPXiFh4hgJGJ+TgPEp&#10;mSp1ht4hfDZ3S2POJ2RJ0kDUXon2JOk2TDwBvAQcJiGiHfnaP+rV167BakfWtk3d8/TKo06Sxu4/&#10;AG/XX5+h9l+4cyGNL5+YJUnrrpQyTQLDPWQn4kGyK/EE8BRpwt4ysDuolWpP527Pv/iEhIr3SbA4&#10;Shq9zwPz7lpI48dQIUlac7XMqb9fYjcZA3uY9Ek8SALGbrJr0ZY4afQsk7Knk/RO8X6LhIyP6/vb&#10;xu5FA4Y0HgwVkqQ10xcmNpEpTfvJLsTDwNPA88Aj5EyJ5oabRld74N4SCQ/tzsV7JFgcITsXZ4Gr&#10;wJKlUdJo80lbkrTq+sLEBjLq9SHge8CL9HYldtWPbcLXo3FWSN/FGTKC9jTZufgDKY9qT/K+gjsX&#10;0sjySVyStOpKKRtJaLiPnC3xPAkUT5Eg0Z507etQdyyRSVDXyOF5H5JQ8RE5VO8jUhp11V0LafT4&#10;ZC5JWhV1mtMMabC+D3iG7E48QfonDpKzJ3zt0TJp2j5F+i7eB34PvElG057DcCGNFJ/YJUl3rO+c&#10;iRmyA7GflDo9B7xMQsUeeqNgfd1Rq9CbGnUKeAf4d64vi7qAo2ilkeCTuyTpjtRAMUWarO8lOxOv&#10;0pvmtJeMjfVsCX2bQkqjLpPm7feBN8jOxUfkpO7L2G8hDbWpQd8BSdLoqYFihkx0epT0S7xCeicO&#10;kKAxhWNh9d3acLqNHIS4k4TUg8C79HovTpZSrjRNszSoOyrp1rxyJEm6bTVMbCS9EfeQ0bAvklKn&#10;J8nuxMaB3UGNg/aci6/ILsUR4DXSb/EJmSI1Z0mUNFwMFZKk79RX6rSVNGE/ScqdHqu/PkR6KtyZ&#10;0GppdyTOkhG0v6+3d0i/xWXst5CGhqFCknRLfY3YG8iI2MfIrsSPSTP2TrIzMY2BQmtjmRyQ9yXw&#10;R+B10sz9MWnwvmpJlDR4hgpJ0k3VQDHN9Y3YPyHlTg+TUqfpgd1Bdc08OTjvE3o7F38CjpIRtDZy&#10;SwNko7akNdN3lfu6d/e/8NezDdo/U/o/3vf5xcXC+qpf+00kTDwCPE3vROwHgFl8DdH62kD6eLYA&#10;+8hAgP0kXLxHGrmv+lwhDYYvCJJWpC424fqwMFFvk/VtU99Ok+eZ6fqxkr+iLJOSBur72ylBi8By&#10;/Xg7w576vkUyz779WPu2v+yhDSXWWN+FUko7iecBUur0A+Dx+vv92IitwZkkj81NpIdnNwkYu4E/&#10;A1+UUi42TbM4uLsodZOhQtI33BAc2sDQkBf0NgRM9n18hrzIz5KridP17eb6vtn68Wv0QkAbCKbq&#10;xydJ3fRC/fhy/fgyKXu4TCbCtMFiAZirn7NE30FapZQ5vhlArgsqXs38prprNE0Oq3uCnDnxH8m5&#10;E1vpPRakQZsiQWKW9PrsI+V4vwc+KqWcIU3c/pxL68RQIQm4rgypf9ehDQdtYNhSb9vq23aHoR0x&#10;urN+bCu5irij/rnZ+nefJiGgrdVvw8gmEgxu9vENwEXgJJkCU+q/t1h/f4IEDurnzdU/ewq4VH9/&#10;pb69Vj9voe58XFdu1WWllEkSAg8CLwH/AXiB7E5swzCh4dJe5NhMTnDfSkLFPaSR+23gy1LKnE3c&#10;0vowVEgdVnckJsnivQ0Ms+SFenP9/VayqNxOLyhsp3dQVbvwn62/33DDrS19gixY252IdrejnRpU&#10;6sfbsoV2R2SKhIHLZMeC+jntCbyX6ue0i97LZLZ9GygukvGTbWCZI2HkNGnuvFJKuVY/d4k0e3aq&#10;fKqUMk0C4ZMkUPyI9E60pU4O9dCwaieT7adXErWX7Fz8O3C0lHK+aZqFW/8VklaDLxTSmOtrdm4D&#10;xBTXL/pnyYLyHvJCvIteeGh3HbbSK2VqdxbaQNH2Taz380lb1gS98izolUq1pU6XyW7GhfqxK8Dx&#10;+r4v6q8vkkBxBThff9+WUC3B+JZLlVJmSLnTU8AvSaB4gjwmZvB1QqOj0Bs9+zbwW+B35ETuk3hg&#10;nrSmfLGQxlANEm0J0wwJABtJMGibG/vDQztJZS+90qY2QGyof0fbQwHXP3cM4/NI6Xvbho/2frY7&#10;FZfJ4uMYCRILZPfiS3KS74n6566SnZB5ej0hy6MeMmq520byPX8K+Cvgb0ig2MJwfl+l71LIz+sZ&#10;4CMSKl4nI2i/AC7ZxC2tDV80pDHRtyPRNk7PksCwh4SG9nYvCRB7SKhodyH6DzDrv91sLOwoaxvE&#10;l0nAmO/72CkSJr4GPiMBoy2TOlE/fp56km/9e0auJ6P2T8ySWvQXyISn75Pyp+2M1/db3bRIdh6P&#10;kbMsXiNN3B8A5yyHklafPRXSCOsLEu2OxGZ6k1AeIVegHyE7EzeWMLU7EG1vQ1c09J77psnXpV1E&#10;byd9HXPkSudFsji5BBwBPidXO4+RwHEGuFxKmWdEDt7q6594GHgF+CkJFnvJ48NAoXEwRX62D5Gd&#10;t930SvreK6Wcbprm2q0/XdJKGSqkEVTDRNsb0TZS7yY7EA/U26PkbIEDJEQ4veebblxAz9TbNrIA&#10;WSaBa5GUBZ2h14vRhotPSNg4U0q5Sp0wNWy1233lTveQg+xeJedPPEMeIz4+NG7aAxzb58B2R3Yr&#10;8FYp5SvSZzH0FwOkUeAVKWkE3GRHoi1tupdciTtQf32QXmnTTvLiabPt6mgXHnOk6fsCKZN6lxy6&#10;9TEplTpNr2djKEqk+sqdHgCeB35MGrIfII+R6UHdN2mdLJOfyY9JA/c/k3KoY8BVx85Kd8+FhjTE&#10;+hqu2/McttNrqn6IHEr2Arn6vIleQ3X/ydb+nK+u/sP0FkiA+Aw4SibMfFJvX9LrwfjLJKn1Dhd1&#10;h2Iz8CBpxv5r4DngPhI03KFQVxSyk3iCNHD/f8BvyM/vJYOFdHdcbEhDqq/EaTuZwf4g2ZV4CLif&#10;3q6EZwkM1iK9A/baxtCvyKjaj4FPyaLlK9LwfXW9SqPqY6htyP4x8F9IQ/ZuUjrnY0Zd1E56e4sE&#10;i38kY2cvDlvZojRK7KmQhki9qjxJr+53H+mNeIHUvt9DFoTbyNXn9nA5F4eDM0Xv4MBCSs8eI83d&#10;X5Hdig9JidSH5JTfc9RRtWu1c1EfS9tIoHiZ3gnZ++lWY750o2nyXDpJLgjMkefQT0op5xw5K90Z&#10;FyLSEKgLwHZayV7SH3E/mdDzNClXeYiUN2k0LJNxtcskXLxDr/fiU7Kj8TW192I1r5DWHortZETs&#10;j0jZ0/NkIbVhtf4dacRdI2WKfyJlUK8D7wGnHTkrrZw7FdKA1NKU9oTrTWQUbHtuwGFS7rSf3jhY&#10;m2lHSzttCfJ93UPG+54g42nfrrejwNlSyhVWoe+ilDJFdigeB34O/C0JpZtxh0LqN01KSGfJYItt&#10;9X1vllJOMyJjoqVhYaiQBqBvvGfbeH0/WXA+Q64oHyIvdG3jddt0rdHSfs8myYJlI5m49Dj5Xr9D&#10;pkcdIbsXx4HzpZT5le5c9PXg7Kh//09IqHiahFIbsqXrNeQ5djcZejFbb9NkV/FkKWXBYCHdHkOF&#10;tE5umOS0g5Q2PUcWfYdIaco+ckV782DupdZQGyQ3ku/vNlLmdpiUYLxHyjCOAMfbvovbCRf1sTVN&#10;FkfPAD8jB9s9TR5rBgrp1tpywSfIrvEW8vP5W+BYKeWawUL6boYKaR307UzsJAvJtvn6ZXJVeTcJ&#10;Gy7+umGC3gnnB0jvw+PkcfEOKYn6EPi4hotr3xEupkj53GHgF6Qp+xBZKFnyJH239mfycXqlgov1&#10;drLuHhospG9hqJDWUA0T0+TK173kyvHzZPH3MFlQbsOfxS5qe2r6DzTcT66WniTlF78h5VEnSymX&#10;uEm4KKVMk0DxDDmDoi152oQlc9JKTZNy1JfJBLdrZAfxZCnF07elb+FCRloDffXt7VjYh0mYeJUs&#10;/vaRheQ07k6oV9vdnoL+KHnMPEom0vwJ+Ag4UUq5TG3mrk3Ze8jZE39F+iiexHNLpLsxSe+wyIl6&#10;+3fS83RtgPdLGmqGCmmV1YXeZrIz8QxZ8D1Hrn4dIDXu/uzpZtqdiw2koXsrecw8AbxBdi+OAudK&#10;KddIedOzwP9CRsceIrtiBlXp7syS4RnT9bYM/K6UctKTt6Wbc2EjrZJa6tRebX6YhImXSe/EIVKO&#10;4mJPt2uanFmylTTxt2eXvAd8AVwkO14/JldUH6Y3wlbS3ZkgAf0hMur5HHAFWC6lnPEcC+mbDBXS&#10;Xeprwm4PrmsDxU/Jycq7sRxFd6YhYfQg2f06SMrovgDOkF6K50mphofaSatvhoT5H5JwAfUcC0/e&#10;lq5nqJDuUN+I2M3AfcBTpEzlyfrrR+mdD2Cg0N2YJGVzW8mu18V6a6c+2ZQtrY123Oxz5OLQNJkI&#10;9edSyrmVnicjjTNDhXTnZsiC7lFS5tS/M7EFy520uvonRW0kjz3I87iPM2ntTJJA/xT5WbsIXAU+&#10;KKVcsMdCCkOFtAJ9h4y1jdiHySFj3ycvOHtwgae11wYMSeuj7bF4hExZu1Lfb7CQKkOFdJtKKZNk&#10;Isg+0rz3FPADEijurx8zUEjS+NpMJq4tk2DfAO/VYGEplDrNUCF9h7o70W5/Pwi8SHYnnqi/30fK&#10;UQwUkjTepslz/sv0hiNcIefIXLnVJ0ldYKiQvkVfudNuEiJ+RMZ3HibNe+0BdjbJSlI3TJHBCU8C&#10;F4BTwOVSyhdN08wP9J5JA2SokG6hjoqdJWM8XwR+BrxEpu/sxCAhSV01SS42PUuCxWkSLE5aBqWu&#10;MlRIN6i7E1MkOLSTnX5U396PZU6SpJQ/3Uv66r4AzgLzpZTzBgt1kaFC6lMDxQy5AvUM8HPgF/R2&#10;JwwUkqTWRuAA8Cq9U7ffLaXMGSzUNYYKqeo7GXsP8DQJFD8nU548c0KSdKMJYBvwAnCJlEGdBb6q&#10;waIM8s5J68lQIfVsITsSz5PeiVfIYXabsX9CknRz7anbT5Ay2XPAEnAcsHFbnWGoUOeVUqbJlaZH&#10;SJD4KdmpuI+MkTVQSJK+zSQpg3qFBIpFYKGUcsKD8dQVhgp1Vi132gDsJSVOLwM/JNvYe8ioWEmS&#10;bsdWslsxTXYoLpCJUBcsg1IXGCrUSTVQbCa7ES+SsydeJidlbyZXnSRJWolN5FDUHwFfkTMsPiyl&#10;XDNYaNwZKtQ5NVBsAR4mT/y/IIfZHajvt9xJknSnNpELVD8j/RXnSX/FwgDvk7TmDBXqlL4dikOk&#10;1OlvgB+QEbIzGCgkSXdngowgfx44CXxKyqDO21+hcWaoUGeUUiZJzesh0kz3MzLl6R78WZAkrY6G&#10;9FXcA3wP+Bw4A3xQSrloGZTGlQspdUINFNvIiNi/An5MriLtx58DSdLqmwQeBf4D8CUphZoDrg3y&#10;TklrxcWUxl49JbudyvFz4H8l4WI7/gxIktZGQ8ptHyQXsT4CzpRSzrpboXHkgkpjrZ5B0R5K9FPg&#10;l+QMih2DvF+SpM7YBjwJPAOcAK562rbGkaFCY6uUMkPOmzhMpjz9BHiO7FpIkrQeNtA7XPUUmQb1&#10;JTkgTxobhgqNnVruNE0mOh0G/hMJFI+SkbETg7t3kqSOmSb9ez8gDdsngIt1GtTyQO+ZtIoMFRor&#10;NVBMkUDxDJnw9FPSQ7GV1Lg6NlaStJ6mgH1kGtRxEizmgSuDvFPSajJUaNxMAXvJE/dfk7KnR0ig&#10;cIdCkjQIbdP2E2S34h3gRO2tcLdCY8FFlsZGKWWKNGA/Sw61+1vgKdIk52NdkjRIk8AucqHrCbJz&#10;sWGg90haRS60NBbqORTtlKefAb8g/RQ7yRO5JEmD1pDXpadJWe7uekFMGnk+kDXySikTXB8ofkmu&#10;BBmaJUnDZhuZRPglKYW6VJu2HTGrkWao0EirjdmbSYhoz6F4BNg0yPslSdItbCQH4r1MGrZPk7Mr&#10;rhksNMq8kquRVXcoZoEHgJfI2NinyVUgJzxJkobRBBlv/jg5u+KZ+ntftzTSDBUaSX2B4hB5Uv4J&#10;eWLegTtwkqThNkFGnz8LvECatqcHeo+ku2So0MipJU8bgAMkTPxn4FXgHnxSliQNvwaYIa9jT5Gy&#10;3c31gpk0knzwahRN0ztE6JekLvU+Uqfq9rEkaRS0PYEPkxLe+4FN9cKZNHIMFRopdfTebjI54+fA&#10;94F7yRUfH8+SpFEyCRwEfgg8SSYZ+lqmkeQDVyOj7yyKx8lJ2T8mT8aWPEmSRlFDegGfJGcrtRfJ&#10;pJFjqNBIqHWmW0jd6avkqs4j+OQrSRptEyRYPA08Cuy0t0KjyAetRsVGMjr2x6SP4jBp1rb2VJI0&#10;6jaQXfiXyAWzjfZWaNQYKjT0SikzZLLT90ioeJpc1fHxK0kaB9PkwtnLZMysvRUaOT5gNdTqFvBO&#10;MnLvVbJDsYc0t0mSNA76S3yfAPbimUsaMYYKDa0aKNpxez8AXsQmNknSeGqAbWRE+n1kvKzrNI0M&#10;H6waSrWWdIZMd/oeCRUPk5Bhnakkadw0pH/wAPAYGZ/udEONDEOFhlV7HsVhUmP6NKkxtexJkjSu&#10;pkioeJ5cSNtiw7ZGhaFCQ6du924lV2peIU+u+/GKjSRpvDWkn+I54Blycc3eCo0EQ4WG0SbgfjJa&#10;7yXgUH2fV2skSeNuE5kE9TS5oLZhsHdHuj2GCg2VUso0GR/7HDng7gnSuCZJUldsIMHifmCrJVAa&#10;BYYKDY0bxsf+iASLXfg4lSR1Szuo5DFq+a/BQsPOxZqGQg0UW4BHSWO242MlSV01DewjPYXtjr1r&#10;Ng01H6AaFu1VmRfJ+NhHsI9CktRNE2Ti4bP15mF4GnqGCg1cKWUS2AE8SQLFU+TJ1MenJKmL2rOa&#10;7iMlUPfjYXgacj44NVC1RnSW7FK8QM6luAfPo5AkdVsbLO4lUxC34WujhpihQoM2RbZ1D5PSp/vJ&#10;iaKWPUmSuq4hZ1U8RF4r7TPU0DJUaGDqNu42es3ZbdmTgUKSpNhGLrgdICVQvkZqKBkqNBD1SXGG&#10;PEm+QELFAbwKI0lSvy0kVDxC+g8tgdJQMlRoUCbJ1ZengVfIboWnhkqSdL3NpPzpJdJ/6GulhpKh&#10;QoMyRU4LfZkccrcVH4+SJN1oivRVPE6atmctgdIwchGnddc3QvZRMipvDz4WJUm6lQ2kUXs/XoTT&#10;kPJBqXVVr65sIePxnsU+CkmSvsskee28l+xazLhboWFjqNB6mwb2Ac+T+tBDeHK2JEnfZRPwIOmr&#10;2Iyvmxoyhgqtm75digfJxKfHcYSsJEm3Y5LsVNwP7MQpUBoyhgqtixoopslp2YeB75H60KlB3i9J&#10;kkbEJNnpf5C8lk5bAqVhYqjQepkgzdlPAT8g87Y3DfQeSZI0OibJYJPHgYexdFhDxlChNdd30N1B&#10;0kfxIjmjwsefJEm3p70490y9bcUSKA0RF3VaDw0wSw7veZyMxLPsSZKklZkk058OArtIWbE0FAwV&#10;Wg8zpP7zCdJg5patJEkr15DX0D31tsG+Cg0LQ4XWVCllgmzRPkK2a+8luxQ+CUqStHIzZHLiHnIo&#10;nms5DQUfiFpr02TK0zPAk+RJ0BpQSZLu3Bby2jqLazkNCR+IWmubyKnZT9a3TnySJOnubCavqdux&#10;R1FDwlChNVNKmSYNZYdIL8Xmgd4hSZLGwyZSTryTlENJA2eo0JqovRTbSC/F8+Swno0DvVOSJI2H&#10;jaT8aQdOgNKQcMtMq6ZOoGjI42ozCRQ/IGdT3ItXUyRJWg0zJFBsx9dWDQlDhe5aDROT5PE0S7Zj&#10;7yeB4qfkbAp3KSRJWh1TJFDsBGZLKRNN0ywP+D6p4wwVumN9YWIjKXXaQw64O0zOpHiM9FN4erYk&#10;Satnioxr308OwTtWSplrmqYM9m6pywwVWrFSyiTZbt1CGrHvBe4juxNP0juPYhuZoe3jTJKk1TNB&#10;bwJUO1p2HjBUaGBc7Ok79fVKtLsSO0iIeKjeHgAOklOz9wP7SOOYB9xJkrQ2ZuidrD0LnBvs3VHX&#10;GSp0SzVMTJAnrk1k52E/KWt6md5Up60kbEyR4NGGEEmStDYmyOvvdvIa7euuBspQoZuqgWKKlDjt&#10;J70RD5OJTo/V236y/doGCUmStD4myGv0DurJ2qWUxr4KDYqhQn/RFyQ2kKsfe0mQeL7eHqA3wm5L&#10;/XOGCUmS1l/bV7GjvnUgigbKUKH+KU5bSD/E/fV2iOxIPEPCxdYB3UVJknS9NlRsr2+ngGvYrK0B&#10;MVR02A07EztIf8Tz5LC6h+mNqmt3JSRJ0nBo6A1PaQ/BuzrQe6ROM1R0UA0TkKCwi0xyehx4gQSK&#10;J0lT9mS9TWCZkyRJw6Qhr+O7yfTFHcCVUsqyfRUaBENFx/SdMbGNlDi9ALxCgsQB8uS0FWszJUka&#10;Zg15Pb+HHDh7hJQ/nSqlzBsstN4MFR1RSpmgtzPxAPAo8DQpd3qWPClND+wOSpKklZogQ1WeJ6VP&#10;20m4OFlKOV/ft9A0zfLg7qK6wpKWDiilTJO+iHtJkHgZeI4cXLe3fmwKHw+SJI2aBXLw3RfARyRU&#10;fAwcrbfTwJX65yyN0ppxETmm+g6umyZ1lo8A3wd+SEqeDpIGLw+rkyRpdJV6uwZcIgHjaxIwfge8&#10;QwLH2frxeQwXWgMuJMdQLXXaSEqdDpBA8T2yQ/F4ff8Mfv8lSRony8AiCRjngE+Bd8nOxcfAh8CX&#10;9WPXgGK40GpxUTlG+kbEbiPjYZ8jdZaPkDMn7if1ln7fJUkab0ukp+IU2aX4DPgT8DbwCXAcaPsu&#10;Fg0XulsuLsdEneq0AdhDDqx7CXiVhIo9ZOfCvglJkrqjPyhcIGHiPdJrcQT4gJRGnSF9F4s2detO&#10;ucAccXV3om3E3k8asX8M/IAcYLe7ftzvtSRJ3dX2XZwjAeIY8Md6a8uiTpO+C3cutGIuNEdYDRQb&#10;yVSnJ4DDpAn7BVL+tIFeI7YkSdIS6b2YI6VRR+rtfVIa9X59/xw2dGsFXGyOqFLKFOmPeAj4Edmd&#10;eITsVuwmYUOSJOlWFoGL9XaMTIr6HfAm6cE4A8xZEqXbYagYMX2H2O0jOxM/AP6K7E5sIzsTkiRJ&#10;KzEPnCA9F38kTd3vAZ+TfgwP0dO3MlSMiFrqNEl6Jw6SBuy/AV4kJ2RvxUAhSZLu3BJwmfRXvAf8&#10;HniDNHZ/TfotDBe6KUPFCOgbFbud9E68QkqeXgTuIaVOEwO7g5IkaVws0zul+yjwZ9Jz8SbptzhJ&#10;xtAu2W+hfoaKEVD7J3aTcqdfAj8lY2N34mQnSZK0+tpdizOk/OlN4DVSFvUJmRQ1766FWlODvgO6&#10;tbpDsZnsRjxBmrF/ATxDyqAkSZLWwiTp1dxKxtHuBQ6Qw3R/R5q6vyylXCQlUe5adJyhYgj19U9s&#10;JtOdvkdKda4xXAAAIABJREFUnl4g4cJAIUmS1kNTb/eSkHEvCRcHSWnUx8DXpZQrTdMsDexeauAs&#10;mxkyNVDMADvI4XWvkOlO36c3KtaGbEmStN7aA/TO0Ou3+C2ZFvUZcB4PzussdyqGSB0Xu5HeuNgf&#10;Ay+R3Yl7sH9CkiQNTkPG2u8l1RR7yM7FflIS9T5wspQyb7DoHkPFkKiBYpachP094IfAq/X3W8nu&#10;hSRJ0qBNkVKojaQkexcJGntIQ/fnpZSLNnF3i6FiCNSSpzZQ/IQ0Yz9Hzp+YHeBdkyRJupUZUl2x&#10;hUykbIPFG8CRUspZbOLuDEPFgPUFigfI2RP/iexS7MLvjyRJGm7tYJlHyXla++rtdTIh6kQpZQ5Y&#10;NlyMNxetA1RLnraRCU+vkh2KF0nKtxlbkiSNggnSa7Ef2EQujN5DwsUfSVP3xVKKTdxjzFAxIDVQ&#10;7ACeJIfZ/Qx4mvwQGigkSdKomSJlUBtIP+geEix+D3wAnCqlXDVYjCdDxTrrO4NiG/A4CRR/Czxf&#10;32egkCRJo2qC9FgcIsGibeLeBbwNfFFKueSZFuPHULGOaqCYJjWHj5Meip+R8bHbMVBIkqTx0DZx&#10;z5JztvaRnYvfkSbuC8CSuxbjw1CxvibJtuAzpH/iVVL+tBMDhSRJGi+TZLfiYXLxdDepypgBPgTO&#10;AgsDu3daVYaKdVJKmSRbf4dJoPhb0qC9Fb8PkiRpPLXncE2TXotNZO3zb8CbpZSTwDV3LEafi9l1&#10;UEqZJlt+zwB/TULFk2QEmyRJ0rhr10IvkN2KXWQd9Afgy1LKnIfljTZDxRorpUyRH5zvA39FDrd7&#10;miR1SZKkrmgnXz5T326ut98Cn5VSrhgsRpehYg3VkqcdJET8FxIqHiSBYmKAd02SJGlQZoD7gL8h&#10;66RZ4J9JsLhssBhNhoo1UgPFdlLm9AtySvYh8oPTDO6eSZIkDVRDgsVe4FngMmnYngGOllIuOHJ2&#10;9Bgq1kA92G4rGRv7E7JDcQgDhSRJUmuSjJr9PgkU24DXgPdLKWcNFqPFULHKaqCYJWVOr5DG7KdI&#10;yDBQSJIk9bRrpi0kVGwiYeOdUsq5pmkWB3nndPsMFauoHm63CThIUvdPgOfwHApJkqRbaUuhXiTr&#10;qHYE7dullDPAgiNnh5+hYpXUQLGRBIq25Ok58kPi11mSJOnWpkgv6nOkumMnmQz1BnCilOLp20PO&#10;xe7qmQbuJadk/2+k8Wh/fb8kSZK+XXsC9+Nk92IOmAeWgdOlFHcshpihYhXUw+32kW27/0CCxV4c&#10;GytJkrRSG0mfxY+Aq/V9b5Jg4enbQ8pQcZfq4XY7yc7EL8gPwE4MFJIkSXdqA/AEUOitV/8EnCbj&#10;ZzVkDBV3oZ5FsRV4FPgx8DJwAEueJEmS7kY7nv8ZEjCmSCnUm3UqlONmh4yh4g7VxuwtwMMkUPwQ&#10;eIhs2Tk6VpIk6e5MkLXWIeAl4BRwjd45Fp68PUQMFXfghklPLwE/JWdRbMdAIUmStJo2A4+RnQpI&#10;2Hi7lHLeYDE8DBV3ZgrYQ7bkfkTGn+3BsygkSZJW2zRZZ71ISqEgAeO9Usplg8VwMFSsUF8fxWOk&#10;h+J7ZPKTfRSSJElroz3H4gVSAnWJjJw9arAYDoaKFahlTxvImLMf1NuD9FKzJEmS1sYk6bF4EjhP&#10;pkBNAJ+UUi4ZLAbLULEy0+RAuxeAV8jhLFtwfKwkSdJ6aEgp1PdJyJis7/uI7F5oQAwVt6mWPe0E&#10;niaTng6TB7WBQpIkaf1sIMNy2kqRq8DlUsqngKduD4ih4jbUsqetwCNkh+JF4F7so5AkSRqEKWAX&#10;OXz4DHCO7FR8DSwO8H51lqHiO/T1UdxHttpeJvOSZwd4tyRJkrquLUt/GbhAAsXVUsoF+yvWn6Hi&#10;u02R6U6HyYP2SWAblj1JkiQNUgNsAu4nVSTHyG7Fh8DFAd6vTjJUfIvaR7GNNGS/DDxPAoZfN0mS&#10;pMFryOF4j5LDiM8Bl0op14Br9lesHxfHt1DLnmbJyNiXSOnTg8AMnpotSZI0LCaAvWS34hRwErgM&#10;fF1KsXF7nRgqbm2aPECfJ83Zj+H4WEmSpGHTkDXtTuA50lsxB/yJhAwbt9eBoeIm+qY9PUzKnp4G&#10;dmOgkCRJGlYbyaTOJRI0loA3Sinnbdxee4aKG9RAsRE4QNLuC2R87Mwg75ckSZK+1QSwg1wMXqY3&#10;YvZD4MoA71cnGCq+aZLMPX6K9FEcwvGxkiRJo2ILKVs/B3wBXCilfNE0zcJg79Z4M1T0KaVMkNFk&#10;7SF33yf1eZODvF+SJElaka1kx+JvSV/FpVLKacug1o6h4nrtmRQvkEBxP5Y9SZIkjZppsqZ7ETgC&#10;nCAH410xWKwNQ0VVdym2kbKnV4EnsOxJkiRpFPX3yP6U7FZcAI6WUuYcM7v6DBU9MyTRPkdOz947&#10;2LsjSZKku7SRrO1OAp8BZ4EFHDO76hyRynW7FA+Sfood2EchSZI06iZIf8Uj5KLxvcDGOu1Tq6jz&#10;OxV9I2TvI3V3z5BQIUkajP6yBF/4Jd2tBrgHeBb4mEyFulZvWiWdDxUkwe7m+hGymwZ5hySpwwq9&#10;0oRJUppqsJB0t3aQC8enydkVToNaZZ0OFX0jZB8Aniejx3bQ8a+LJA3QIjmw6gyZ3rKH7CZbkirp&#10;brRVKS+RsytOk2lQl23aXh1dXzxPkReswyRU3EtexCRJ668A88CXwLskSDxOprdsIc/P47RrUfre&#10;2uMorb2N5LiAHwFfkR2LOWzaXhWdDRV1l2KWnLj4Ehkhuxmf2CV9t1Jvy2SRO8F4LXYHZYFcPfx3&#10;4N/IC/3npN/tEWAXKYcah+fpQv5/banXRsYvNEnDZhLYTi4kfwy8B5wspSy5W3H3OhsquP6gu+eA&#10;/bi9Lun2LANXgctkgTtLSinHYbE7KIV8Tb8A3gBeJ1/fz8koyJdIieoB8vUe5efrZbIjc4b8f78g&#10;YeIZcqHLx5G0dqZJL+2j9XaUhHubtu9SJ0NFnfi0GTgIPElepDYM9E5JGhUFuEIWu0fJ4vYgGUk9&#10;6ovdQVomB1O1Vw8/r78/V29fk8OrnicDNbYzmk3ciyQ8nSAlXm8Ab5MSjJeAvyHhaSs+lqS1MknK&#10;oJ4nZ1dcLaWcbZpmabB3a7R1MlSQlLqLJNQHSK2uJN2Oa2RB2F5Nb8hu5wS9YDFqC91hsECCwxFS&#10;63ylaZrFUsoZsuA+R3YsvgZ+QK7o76G3QzTMX/O2XG4BuEh2Jv4MvAb8DviEBI236q//K3lM7SMX&#10;vIb5/yaNognSR/t94Di1aZvsjuoOdS5U1F2KTWQCwAskWGwd6J2SNCqWyGms7wK/An5d3/c1WfzN&#10;kheqUbyCPkhLJDQcBT4g4eEaQNM0y6WUdmfoEtmtOA68SoZsHCQ7z1Pk6uMwfd37w8Q8eex8QsLo&#10;v5EQcaJ+bJmEjf9Gdmv+K/Az4CHs95PWwjZyceKHZDjE2VLKnLsVd65zoYK84Owk51K8COzFLWZJ&#10;362Qq1gfkUXhG2Shu1g/Nkt2Pb9PDlkal4bitbZMvq5HSIP2e8DF/tnx9ddzpZR2Uku7a/EFKRW6&#10;jzyXb+f68bODChhtmFgkpXKnyH39gOxQ/IH8f880TbPQ93mLpZS2Uf08CSD/kTymduNrlbSaGnKM&#10;wNNkd/RTcoHoyiDv1CjrVKiouxQz5AX/EeylkHR7Fkl9/4dkd+I18gJ0hSyKj5GgMU0Wvd8j9bqz&#10;GCy+TSFfr2NkId0Gtfmb/eFaDnWufs4FeqNnHwEerreDZKEwQ17j1rM0qg0S10hQOkv+bx8B79fb&#10;kXq/L93s0K06geZyKeVNsjNztt5eJeFpZu3/G1JntGvCF8hz0Ed1t8ID8e5Ap0IFeXHZQbaTD2Ht&#10;s6TvtkCm9LxPSlZ+RRayF9tt8lqe8ykp47lIrjK/Sp5nttK959rb1X5t3wR+S3YpzpOgdlN10X21&#10;lPJl/dwjZHrfIXLF8en66z3ka7+JXDxqy6NgdZ73+8+YaMcLz9PbRTlGypg+IKHic+opvsC171q0&#10;NE1TSimfkjrvs/Xz/rr+37wYJq2OhqwFHyDPHW8B50opVw0WK9eZF7q6S7GBXOk5TA5U2obbyZJu&#10;rpCQcIZM5/lHskvxPmnq+8thSXUBeJUEi/bq8nlSE/8YuZjhc831lkkA+wj4DSkLOgEs3s68+KZp&#10;lmqYmyPfo8/JTtKfSK9cu2uxj5QObSe9CTNc33uxkp2M/gCxTB4D82Rn4gp5XBwlofNtEiiOkcfE&#10;Ink8ldudh1//j6fIztil+m/8ov7/NuIumLQaJsh68Fny/P4l8FUp5ZpnV6xMZ0IFedBsJYfcPUtS&#10;qadnS7qZNlCcA94hgeIfyQL4LLBw44tNbSieJ1ep/51cYZ4nV+OfIRPnFO2ZFJ+TsrHf11/Pr+RF&#10;vP7ZJWCplLJASo7aUa27yA7G/fV2oN7uIa8F0yRc9JdJQe8ww/b3y/XfaEPEAgkyV+jtSnxFmse/&#10;rP+PY2RX4jxwV6UUTdMs1AlYf6TX7P0fyVVVL4xJd68hIf0Z8vP7PvnZXqC3I6nb0KVQ0R528jAJ&#10;FNuw9EnSzbXjTd8G/oWUPL0PnGuaZvFWn1QXuQu12fYteiduT5KLGVvweQeyOD9OFsqvkTKhi3e5&#10;+F4CrpRS2p2LL0hp1HZSCrWPhIr95LVgK/l+bKIXKqbJ4mKWhI1FejsEcyQInSf9HOfJzsQxEmTO&#10;kZ2Xi/XPLaxW+UTtJTlLdnPmSHiaI2Nnd2GwkO7WJHmeeIIM8jlKfu49EG8FOhEq+g67u4+Eit24&#10;bSzpm9pJRMdInf+vSa3/B3xHoOhXy1baXY4pUno5Qw7b3Ey3g0U7lvcdEijeIlOQbutr+13qQr7d&#10;VZirV/k/J1/3reSCUntry6GmSKDYRAJFe4jhHAkP7eKi/f0FEjYukjBxZa3rr2tgvVhKeYfsWEzU&#10;+/4sCU5dfkxJq2GSXHRoy6DO1QPx3K24TZ0IFeSJdw95QX+U1DdLUqud2nOe3sjYfyU7FV+RBeRK&#10;Z5e3J0S/S2+87CR5DurquQPtFK33SaB4g3x9bzrtaTX07R61YeAEee1r6PVHTJFA0R6kt0QvRCyQ&#10;71u7m7HYd1sCltZz0dE0zdVSylHgf5LXslny2ubgEenu7SKh4hPqlDbcrbhtYx8q+nYpHiSzvg/V&#10;30sSZFE5R8px3iSB4nek6fdU/djySheOtXl7kd50o/7a/MdI6U2XgsUC+Xq+A/wTCW2fkJ6DNV+U&#10;13+jANdq/wX9/25ttG+4PmyU+n1s3/+XP37j56+zy2T37P+lF3iexj5B6W5toXcg3pukjNJQcZvG&#10;PlSQF4Lt5OrgUySFdumFXNLNtScdX6B3TsJr5GCyT+v7V9Q4fKO6IG0X02/Vd28ki7/H6q+7cHV5&#10;gV4PxT+T4PYhcH4Qp9fe7Hv6bfejL5AMhfq4ukQWPW153XZS4tuF13VprbSToB4mF6PfLKVctATq&#10;9oz1k0+9ujRNGvQepnfKraS1116Zv3GazjBYJLXwJ8jV8nfI7sTbZMv7MqtU1lL/jmt1NOjb9Gr2&#10;p8jQiHE+IK8Nbl+TUa//QHYoPiWBYlX6KLqoPq7OlVL+TMq2tpFzLO7DcyykuzFFem8fIuvGk46X&#10;vT1jHSqqzWTix/306mUlra1r9CbktFd+trD+Jxy3+seBXiElSR+RMPEOKSU5ShqI59eo6XaRTAv6&#10;I7m4sQS8TK6GbSMXQMZp16ItK/uaXFH/J3J44EfU0DawezZezpNdtkJ+tn5OXu98rZPuzAR5vXqE&#10;XJD+nBvOJtLNjXuoaBczB8ghSF2rYZYGoS11+RNZrG+gd4r9XjKBZ4Ze/fpaLqTbBuzLpATpc7Ko&#10;fY+MMf2C3nkCl7nNg9fuRC1ZuUZ2R35LJgedAH5ESjP3kq/VOASLZRLeviTlZL8i/+cjwKVBlDyN&#10;qzpu9hT5Ou8m02t20d1hANLdashF6CeA56kjr0sp6zqUYRSNbaiopU8bydbVfeTJdmz/v9KQWCYL&#10;yX8B/o4sIjeQMp/H6tt7620fvYDRf/jYalkg5wWcJiVO75Mw8SEpvzlNgsQ1EibWdCQo/CVYzJPQ&#10;NU/v8LQTwAtk12Irox0slslO0PskSLxGyr6OYaBYEzVYnCFf792keftFPMldulNT5ELY86Qf7jPy&#10;nO3z17cY50X2BEmaB8lV0r345CqtlUKecE+RReTfkWBxmvwsfkzKjO4hV1LvIwGjPYxsF72zAWZI&#10;EJmmd7I19WM3/gy3JU3zpNRmjowAPFv/7TNk0X6UBIv2pOOLJEyseKrT3ar/3ny9utyeynyq3s8f&#10;AI+TheGoTfIp5P9znLwIv07vjI9TrF1ZmWKB7MT9igTTfWR33tc9aeX6J4c+SkoMz2Go+FbjHira&#10;for7yGQMt4KltTFPzhv4PRlz+WuySF6oV+fnyMLyCFno7CAL5wOkZvV+Eiw20TukrH8yUnvScduL&#10;0AaJeXqnHJ+jFyI+JaVNp+kdUna1/vlF1vlsgZupV5cvkcBzkYSdkyQQPUvC1gYG04Nyu9qpSIvk&#10;//AZOXvi16T87TPSW7Mw6K/3uOv7OTtCwtzD5HXvIKMXUKVhsZ3sWBwkF0wcL/stxjlUtAfeHSQP&#10;Cklro53u83vg/yELyuP0LSTrCdPLXN8o/Tm5iv0GCRS7SA/UDL3Z+xvpnX68sf57F8nC+wq9CVNt&#10;cLjU9/ELZOdiqd4K9dyBtfkyrFzTNMu1HOoEva/L8fr7F0nYmiXhYi1KxO5G2/x+iQTGT0hd/2vk&#10;wL/j5P808ADXFX2jZt8C/hv5mfkZKTeUtHLbSLXL48DHpZTLTq27tbEMFaWUtnP/MXIg0H7cApbW&#10;Qls//2cyLvR16mFBNy4k+2b9LwOLdTF9lewwHCcL5/bk6XYM7XTf+yfplVnNkQVtewX/Wr21Jx2v&#10;W5/E3apfl8VSygVqQyAJFe+TBu5HSLjYy/CUsyyT791J0qPyLilve5eEizOk3MlSgXVWg+pZ0j/0&#10;Z3La9h7crZDuxCZSAvUyeY47XUq55IWSmxvLUEFedHcBz5FgsYPhLR+QRtlFsnj5Z+A3pNzl6u08&#10;4baL6XqbL6Vc5vqf05udb1H6btzq/aP4hF93c9rG8YtkJ+ctUsbyZL0dImVj/RO01ssSaWw/Q0LP&#10;Z6TU5iMSJNpJWpdYwylaui3tMIA3yONnB+lhGoZAKo2SadIL+DzprfiYugM7yDs1rMY1VGygd+Dd&#10;Hsb3/ykNSiGL36MkTPwrWVhevtPF5C1OLe7UE3ffQXlnSLD4kuxYvE12LZ4kW/EH6ZWLzZIXvrUo&#10;j1oioW+O7Ch9Rm9n4n3y/T9DgsQcKXkb+t2hcVd3Ky6SK6u/IYFiP905wV1aLW3D9v1k13gvcKqU&#10;su5DPkbBuC62N9ObKOMJ2tLqWyRXQn9PDjT7ALjik+zqqIvCa6QHpd0d+JQ0P99HGtwfIAHjfmAn&#10;1weMW51ifuPZIG05Wvu2vS2Rq90XSZj4mgSKd8n3+jOyW3Gh3sdlhqxfRSyQ3qIPSOB/kfE5B0Va&#10;b20Z1EHyXDw/2LsznMYuVJRS2uPVHyEPgNnB3iNp7CyTaUt/JmVPfwLOWz+/uvp7UEop7W7BGbI7&#10;sJWUtOwjAePBemvP/thEQsZmUvKyUP/aDfVjG0hwmCMvjldIgGhPQW9LnI6Svolz9KZrXSBBZx7L&#10;nIZW35kon5LdpdPkMTNMzf7SqJgiz7X3k5+jC3jC9jeMXaggOxM7yTd/FzanSavtMlmk/COZ3X3S&#10;aRhrqy7cF4CFUko7JeorcgV6K7mQso9sze8gwWETeT6cIWUv/e8r5EXxEr2+lkskULTjeU+T3ajz&#10;9BrjF6m7GYaJ4Vf7dL4mfU/vkcfHTgwW0kpNkufY++vbrzxh+5vGKlTUU7Rnyfi8B+mNoJS0OhbI&#10;AXKvkVrtz3Fu97qqPQvL9AJGOz3rQzIdajO9Eijqr7fW97fN3ddIqLhS/8wkvala8323K3jGxEhr&#10;mma+lHKETGY7SCYibh7svZJGzgS5ePMEqYT5iDyPukPfZ6xCBfmmbyW1xg/jLoW0mgpZwL5FTsv+&#10;mLtozNbdq1/7JWCplrpcJgGhv2digt5p5O37276Jtqm64fq+ir9M0/L7OxaOkwsBD5BgYaiQVmaC&#10;7PI9BRwGfkcuzBgq+oxrqNhHvvnj9v+TBmWZXJU5Qp5M38Y+iqHSBox6yOBN/8gNv79pWDBEjKXL&#10;pFTuT8Bfk/JgSbevITu995IBGbvJrr079X3GZtFdS5/aULEFJ1xIq6E9BfsyGW/6Gpn4dJxe86+G&#10;yLeEAsNCRzVNs1jHFL9HJkJJWrl2vOxecvF6UynlqmO0e8YmVJBv9kZyLsUuxuv/Jq2nQmrpT5GG&#10;4LNkEtDHpI/iPVL25BOpNDqukiurX5CyjS3YsC2t1BSphLmPTNg7T6+MtPPGaeE9Qb7BB8gZFbP4&#10;hCndjrYuf5HsPlwk5xC8RYLEV2Qxcrz++pxlT9LIWSIXCN4mhyg+jofhSSvVkAl7D5GL2Cdx1/4v&#10;xilUTJJv9AGyNeUhP9J3K2TKz1myM/EVOZvgbRIqviRXNS+Q2tFFdyik0VPPrbhMyhcfJa+T+/F1&#10;Ulqp9oTtg8BnpRQHllRjESpqP8VGUuN2kJQ/uUshfbdrZBfi30iQOEpvV+IMKZlY9BwKaSwskmEL&#10;7wLPkddMXyulldlE1pqHyM/SKTwIDxiTUEGvK38nufKyY7B3Rxp6hZy0+y7wDvArcs7BKXqnJXvA&#10;mTRelkh/1IfkjJmnGJ91gLReNpKdiufJRLVPMVQA4/Nk0pDyp81k+pOlT9LNLZKeidPkROx/IguM&#10;T0ivhE+M0pjqK4H6jCyELGWUVm6alA8eJg3bm0opc16EG59QAQkVsyRMLNXfS4r2MLOzwB+AN8ju&#10;xJvkQLs5XGBIY6+Olz1BdirmSCmHpJWZJuWD+8nF7Au4WzE2oWKKTH7aT8bkSeoppHfiHAkR/xfw&#10;OtmduEB6Jjp/hUXqkPNkp+JzUsphsJBWpj0XbS8puT9eSlnq+mvpuISKGfKNfQDPqJButETKHd4A&#10;/hn4F7KgcGKF1E1XSKB4i7x2zuDuvrQSEySQ7wK2k3Vn50/XHpepD5uAe+htQ43L/0u6W4tkktO/&#10;Av8n8Pfk7AkDhdRRTdMsAF8D75P+qs6XbUh3YIqEij3YywuMweK7lDJBein2km/uhsHeI2loFDIW&#10;9jXgv5Edis8AG8okXSTjo0/jFVbpTjTAbnJRezNjsKa+W+PwBZggQWIHaZqxNlRKoDhPxt39H6SH&#10;4uumaTpf8ykJSJP2MXLg5ZUB3xdpFDXkYrZVMtU49B40pAt/Q30rdd0ymfL0R+DvgN8BJx0XK6nP&#10;AtnJ/BpDhXQnGhImdpMhQZY/DfoOrIIpsu20A7+h0jK9HYq/J2dRHG+axvIGSf36z6y5OuD7Io2q&#10;WbL+3MJ4XKi/KyMdKkop7S7FTnIAyQwp+5C6qJDTsD8A/gH4n8BH5HRsSeq3TMLEWQwV0p3aRNag&#10;u4ANdV3aWSMdKqpJMs7rIL3D76QumidjIv+x3j4ArjZN46F2km7UhopzwCWcACWtVENK73cD95Lz&#10;0jq9WzHSoaI2nM6QpDiBgULdVYCTwG+A/0FGRV4yUEi6hWUy9elyvS3gTr+0UlOk/OkA2a2YGezd&#10;GayRDhV1m2kL2anw4B512VnSR/E/gbeBc055knQr9flhgRyOuYBjZaU7NUvOqthBxwcGjfo2zSTZ&#10;btpL70RDqUsKGQ35HvAr4LfAaXcoJN2G5XpbwPIn6U7NkDXoVjoeKkZ2p6LuUrSTn3aTYGGoUNdc&#10;Az4lgeKfgc/qabmSdDsWSbCQdGfaULEdmOlys/bIhoqq6Xs7iT0V6pYlMg7y30hj9vuOjpW0Am2j&#10;6S4cyy7dqWmyS7Ed2Mjor63v2Lj8xwtZYFlDri65ALxJr4/i4mDvjqQRU8jUuPbCnKSVa0PFDgwV&#10;I2+63hYxVKg75oCjpOzp34GvbcyWtEKFXIzwRG3pzk2RZu1t9e1UV0ugRj1UtI3a23DbVt2xDJwA&#10;3gD+BfjSsidJd6AhfVlzpFlb0spNkKMNtpE+3842a49yqGhIc8wu4B56Z1VI46w9NfttskvxQf29&#10;JK1UQ8o1CgkX7nZKK9euR7eRMqgZOnqhe9QX4VPkmzeN9aDqhnngCPBrUvZ0tmmapcHeJUkjbGN9&#10;606FdOemSahom7U7aZRDRUPuf8H52uqGRXJq9mv19ikuBCTduYYc2rWTjp8ELN2lSa6fANXJnYpR&#10;P9eh3Z1wxrbGXSHTnt4G/gl4q2maSwO9R5JG3QQJFHtIg6mkO9MfKjbR0VAx6jsV0+Sb19mtJnXG&#10;PPAZ6aP4PdmxkKS7sQycI31ZBXsqpDs1QYL5LKN/wf6OjXKomCSH9uypt06mQnXCMnCK9FD8DzLt&#10;yRd/SXdrAfiQXKj4CJu1pTs1QS5wT9Ph9eiop6m2MWYbox2QpG+zTKY8/Xfgg6Zprg74/kgaD4vA&#10;x8DfkzDxc+BhYAu+pkor0YaKGbK2niilNF27ADjqoWKy3jqbCjX2CnAM+Ld685AqSauiaZqlUsoZ&#10;4LfkuWUe+CXwOJ7/JK1EO555MynLn6KDg1RGOVQUcv+XyME90rgpwCWyQ/HfSR+F42MlrZoaLM4D&#10;b5Hnl0KqAJ6gw1NspBVq+3y319sGsjZ1p2KETJInQetANY6ukFrnfwDeBa51bStV0trrCxbv0TvE&#10;ayNwiCyODBbSd2snQG2ho6dqj3KoaOs9l/CcCo2fBeBz0pj9R3LInYFC0pqoweIc8CYp4ZgkpVAP&#10;MdprBWm9NGT6U/vz07kwPpJPFKWU9uC7CZIGPbRH46SQaU+/B/4F+MJTsyWttRosTgOvk0XRxnq7&#10;lxFdL0jrqCG7FG2o6JxRfpJoyP1vj0V3UoXGQQGuAu8D/0jKES4P9B5J6oymaUop5RRp3p4iF+5+&#10;Chz6hBLrAAAgAElEQVRgtNcM0lpr6E0k7eRo2VF+gmi/WRvxJFCNjyVS9vRrMu3pvGVPktZTX7B4&#10;nV6J8c+AB+jgQkm6TQ3pqdhGR3uRRjlULJO682vkCc8SKI26ZeACuUL4K+ALOjiSTtLgNU2zUEo5&#10;CbxBqgH2A/vIYsnKAOmbGlL6tIWsSSfp2Gv4SIaKehVlmYSJK/W2iQ6mQo2VeVL29K9kvONVdykk&#10;DdAC8DXwOxIotgKH8XA86VamSPCeAZquHYA3kqGiWiYhYoEsxqRRtkSas/8V+ANwqmma5cHeJUld&#10;Vi/gXQM+IaduT5Fdi4fJhTxJ15snr+ednP40ylcaGvJNW8ZzKjT6LpKm7NeBo03TGJQlDVy9uDEH&#10;HCUT6d4kF0A6VdYh3YZl4AxwnqxJS5d2KWD0Q0VDvomO29QouwocIdOe3gLODfbuSFJPXRhdAt4B&#10;/m9SDnVmoHdKGk6L9E6m71y1wSiXP7XbStN0tMteY2EROE5Knl4HvmqaxiuAkoZK0zTLdSLUG2QK&#10;1P3ADvL6Kykm6Z1R0aldChjRnYp6+F1720zGdxkqNGqWydW/D0lZwUdk10KShlHbuP2HevuSDl6N&#10;lW6hoTf1qZM/F6O8U1HIVd5pPKdCo2mBvCj/EfgzqVNeHOg9kqRbqLsVF8jz1S4yZvZecl6UpPws&#10;TNMbJtQpI7lTUes7C2nQvorTnzR6lslj90MSKj4G5rvW1CVp5CwBZ8lgibeB09i0LUFCxKZ6mwYm&#10;a2VNZ4xkqKjaqU+XgMt0sHZNI20BOElKCN4FzjZN48ABSUOtXvhYIIdzvknO1rlER8s9pBtMkhKo&#10;KdypGCnLZIfiAhnHaajQqChk5NyfSdPj53ilT9LoWCa7Fe+T57CvsGJAKqQCYW7Qd2RQRjlUtOVP&#10;hgqNmnngUzJC9m3gnGVPkkZF0zSlaZpF4BgZMvEuGTHrbqu6rJCfg7Nkfbrctdf2UQ4VkKsll7H8&#10;SaOjkBGybwB/Iidn+0IsaRSdJxdGXiN9YZcHe3ekgVui16TduZLAUQ4V7fSnKxgqNBoK2Vn7kPRS&#10;fIYjZCWNrnkywe5NcoDnBXwtVrdNkb6KdqBQp4xyqIDUobflT17t1bBreymOkFrks/i4lTSi+k7a&#10;/oSUQH1FBxdSUtV/TkUnX9tHOVQUeo3a50nA8MlMw2yRTHw6QnYp5rpWbylp7CyRA/H+DHxAdl87&#10;V/YhVTNkbd3JM6dGOVRAvmlXSfnTHIYKDa92tvsfSenTcTp6JUPSWGl3K94hz2/HSJOqr8fqogl6&#10;5fmOlB0V9QrvMlmYLZBQ4dURDat58mL7B+AjPOhOY6qUMlFKmay3zr2odk19Hmt3Yf8A/AY4hRdN&#10;1D3L5LHfHgjZudf4qUHfgVXQHoJnqNCwWiS7FO+Q8oAzdPDJRuOpBocpsu2/id72f8mHS0Ovxrgd&#10;rLFEB8ctjqv6fZwrpXxEQsVjwE7GY40h3a5l8vp+hjpSdrB3Z/2Nww/8Anmhso5Tw2qelDv9mexW&#10;2EuhkVZKmSBBYZoEiW3ALmAPsKV+rOn7MxvIhZ8TZFrQReBiKeUysOBY5bHxNZkE9RHwMLB5sHdH&#10;WlcNeb2/ijsVI6k9vfAcToDS8LpKwsQH5FwKT8/WyCqlTAOz5Er0LmA/cC9wsL7dQXYrpugFio3k&#10;4s+X9fY5OdfgM+DrUspF8iLs7sUIa5rmSinlc+At4AUSMkd9nSGtRHtBZRlDxcgp5OrXeQwVGk7t&#10;ZJT3gKOkoVEaSaWUSWA38ARwGHiIhIq9JGBsJ4Fjmry4trcJUg7wJAkXJ8nV7HfJuS2fkuDdnkSr&#10;0XWO9FY8Qx4rBwd7d6R11emRsqMeKqAXKi6QK13SsCikfvwoKX36imyNSiOlljttITsRzwCvAC8C&#10;D9T3byQ7Em2YmOCbk09mSZlUqX/PfcCj5OfjCPkZebuU8gVwxR2LkTVPzq34IymB2kUeHzbta5y1&#10;xxxcJK/7nRwpO+qhopCrWhdJsGjH2PnkpWFQSMPWR2Sn4nzTNPb9DIG6SG5vDb3TT5fp681yYfuX&#10;r9V24BHg5Xp7HjhU33+7z7dtjwXAVtKLsbv+PU/XtzuAX5OgMXf3914DsEim37xJGrYPkgA5M8g7&#10;Ja2xNlScIjuu9lSMqAWSCi/Qa9ae/NbPkNZeIY/Nr0gvxRd09MrFMKgTiNrm4nZK0Sy5ut5OKmoP&#10;LLpWb1dKKdfo1fp3KhD2TW3aRnYUfgz8EniOlDtNc3cXcKbILscsqb3fTa5ozwNXSynHgWsGu9HS&#10;NM1ybcB/H3iDhNHd5Ps9smPspdt0kZQ5W/40apqmKaWURVKje6G+XcRQocFrS5/eAv5E6ow7tSgd&#10;Bn1hYgNZHO8kC+IHSFnGlvqxGXLVfTO5OPExqfc/Tq48nakLpaUOLXLbHYqngB8BPyU7FHvJ12w1&#10;tMFlgvRmvEiexxeA3wJfllIWOvQ1HxeLpJesbcY/TH62DBUaVw250LJERw++gxEPFdUy1zdrL7B6&#10;L3jSnVomi6MjpJTDhdE6K6VMkRDxAPBgvR2kN61oG7ky3vYBtH0B10iQOEF2mN4jZ4x8DBwvpVwa&#10;9wlefT0UjwM/J4HiCVY3UPRr6t97EHiV3k7fNdLU7S7fCKnPdfOllFOkAf88ToLSeGvP67lZP1ln&#10;jMMP+DLZLm/Hyo71i71GxhxZiL6Ph92tuxoo9gEvAT8jtd0HSBnGVlJy0x7S9o1PJ8HjMKmNPUx2&#10;Ld6vtw9qM/HFMT5fYSOpg/8h8Nek5Gkba18Xv4n0VkyS5/SzpBTqwhh/rcfZBTI++Bj5eZzG3QqN&#10;p2Wyy32NXATpZGXCOIQKSKg4T69ZWxqkJXKl+5/IVe55dynWR73Cvgm4n5TS/Cfgb0ip0xS9K0jf&#10;diWpv6F4N7li/wDwfbJb8TppJn6nlHJ23HYt6tdwJwlTP61vd7M+i8GGXrB4hewWnSNB7qo/RyPn&#10;EhkX/C7ZHZytN2nctCV/p0mVQpdKZf9i5ENF7atYIFdEDBUaBhdJmHiXHHZn6cb6mSVnIfzvwC9I&#10;k2h7wvOdaMty9pKF9kESMA4Cfwf8vvz/7L1nkxxXmqX5eKRGJpDQBAGQoGZRgaIUS4vu6p6e6e6x&#10;td39m/tlx2xnp7tna0qwWCSLWpNQhNbIBFJnxt0P5156IAmVQEb4dffzmIUFFAlHhPu997zivCFc&#10;algUfRRldb6P+im2M/jo8gjKLv0MCfSLlBFAUx/mUQnhp6h8bj8WFaaZrKFz6MX43qQ94Z6pvaiI&#10;LKNo1kXUHGtMVSyjxsS/oI30WrWX0w5idH0rOgSn7MSzqIznQUmZi+QcNYS+5xlU5vZxw4TFbuAl&#10;VDq2j2p61AqUXXoeRbrfR2WEFhX1IvUnfYVKoJ5H36sxTaRAZ9DWztlpiqhYQbW3Z9FGv0pz/m2m&#10;XsyjwU9/A846S9F/oqDYBbyCshO/QkO3NkNQrKdAkdbHgZ9T1s1+GEK4XGfb2eiUNYGas3+ERNlU&#10;hZc0jDJETyBxcxTVLJuaEO1lb6BsxVmUxV3DDo2meSQn0jla3NvblIP3Kko3nUXRrGW0aLW2A99U&#10;QhdF5b5EA+88PbvPxIPwJJry/C/A39P/EothFG19Mf44bSYLIYT5GguLJM5eoJxFUfXhL5We7QMm&#10;QwgzbY0A1phlFPRLZSErtNwhxzSOgLLW54iB7RBC0ca1qhGiIvZVLCFBcQVFsyaqvSrTMtJcii9R&#10;qcZ5XKoxCFL9/28oXZ7SpOx+MoRmOLyEvveLSFCeCiEs1nQzGUHNtE+hz7RqQQG6pu3ourYDl0II&#10;HohXI3r252uUfY+2fTdNokBBxJPEadptXaOaZO22hpwmruG+CjN4VlGU4h0kKuZqHLGuBTFLMYXK&#10;dH6GmrIHObW3g7IkT6JyodcobTNrRU9PyjPo89xNHpHkIfQdH0DX1I+SNtN/ltGB6xu0R7fywGUa&#10;z3UU1G7t3t8kUdFFouIySrF60TKDoovuuQ+Ad1H9sLMU/aeDypAOI0emKrKTBfAQ6uf4ITr81jEK&#10;O4wyAa8gkTRBHqICJCT2otKscfK5LnPvrCJR8RXK4np/Nk0izaiYR+V9FhUNoItU4jmUfvKiZQbF&#10;MnI2eQsNR2ut88OAmUIH4FdQKVJVn/kWNCjuWSQq6miZOYr6Fp5BB/ic9oZhlEWZQlkgP1v1o4sm&#10;o3+JxEVrD12mkSyigHZyBGzt/Z3TxvGgdFHZ0zn05XrjMYPiBhITHwHn7PjUf2Lp0wFUdvQSEhVV&#10;rmejqDxnP7AthJBDP8JGmEQuS3vJL9PSQRmKEaCVzY91J5aC3kDOeCdoqYe/aSwLSDRfQKXPrV2j&#10;miQqAooYp2ZtH+zMIFhD99snqF7Y/Tx9JgqKEVTy9BLVzVLoZQQJm32ojGi02su5d2I/xU7k+rSH&#10;/HpCOuj77Z2IbupHFxkanMVDak1zSEPvziJR0WrXxyaJCijnVVym5SkoMzCuocnZ7wLni6JorT/1&#10;AEmD0Q6hsqMcmneHgG0oe7If2BoP63VgHImJR1CZUW7XPYQyKWNAJ4pKUzNi9PY6ckmbw9kK0wzW&#10;0LnzJLq3W30GyG3zuG/igrWGDnmXUKq1tSkoMxDS9Ox3UKZittrLaQ3D6OCek/VpOvjuQ/an08Bw&#10;TQ7Ak5SN0FVnfG5FcoAawfMN6s4iOnx9iDK8Fham7iQ7+Qvo3Nnqe7oxoiKyRtmsfRYtYMb0g1T2&#10;9CnKUpx1lqL/xOj/BIqqP4MO8TmsYwUqedqBsihT5CF27kgUPVvR57iL/EqfQJ9tatDuYlFRW2K/&#10;2RHgv6MJ6d6jTd3poHL7lH1rdTA7h81404jZikXgOPAesq5z7abZbFL/zgkkKD6l5SnPAVIgUfE4&#10;yggMkc8hcwg5P31bqlPt5dyZKCiSEDqAshU59oKsogz0dfTcuay13qQetOO4B83Um4B6KG4gO9nW&#10;r01Zb3r3yQoSE58BZ2h504zpG2so0vYF6uFp/WIyIEZQ/f/TKLqei6AAXctwfEE90uBpMvhDSAzl&#10;uCcsomftHLDQZmeVhjCPBMWXyILTmDpzBVnKX0bnzVavTzluIA9Kapo5hr7ohWovxzSQNdS38wXa&#10;HBc9PXtgjKOypyeRy1JuomIEZSmGqIfQ7KDPcQ/5uistoQDRRbye155YJnoZlUFZVJg606UUFZeA&#10;5bYHPRonKuIXOod6Kk6itJQxm8kiirJ9jHspBs0W4HuoQTu36cqpnGhLfO9mvsGkUrJdaMbGEPlF&#10;2QKKbKfBUi5nbQaLyOTiatUXYsx9kkqfLqEs6jU8yqB5oiKyjDrxj6Iv2pjN5DpyL/kC318DIw6U&#10;m0a9FDvIr6m4N1MxfJc/mwMFEhT7UXP5CHmJNNDh8wKKBM46I9gYVlGZ8hnkmufv1dSNLrp3T8fX&#10;DXwfN1ZUJBeo0ygS4kiy2SzmUYP2x8AlH3IGyhQaePcIqv/PkQJtLAEYytxStkCzNXagrE+O+0ES&#10;FUdx1rlJrKLv9W20lra+Ft3Uki4KLF7F/btAnpvIAxMPemkzuojKobxgmQeli+6pD5ERgOdSDJYJ&#10;lKV4FJUY5UZyn7tMPe6NDhJq0+jzzE0ApdKnc6iU1f0UzSEgkXgclUHN4z3a1It0v95AQezcy10H&#10;QiNFRSQ1gx1FGQtHQsyDsgKcAv6GshU+5AyW3vr/HIe0rSExcQ5FrtZy3WRiBmUcZSl2ocxPbqKi&#10;iz7HVHvf+nrlphCfi1XU5HqeeCir9KKM2Rir6IyZ7t8s1/pB02RRkRas94GP0KbkRcvcLwGJiOMo&#10;UzGb64GxiYQQRlBEfQ95zlKA0nnuMvlPVh1CQ+/SfIox8hMVq8hw4ytcWtBEuqiS4Bv0zOT8vBiz&#10;niU0o+oYFsXf0mRRkVLn36Av3bMEzIOwhkowPkH3lF1oBsswaih+AUXYc2QFHZKuAkuZi84CCYkD&#10;KPOTG6k85hTKCs67f6lxpD36KnL28vdr6kSaiXYJ2crnvN4PjMaKivgFr6Aa+BPx3ZEQcz90USTi&#10;beCvOOs1UGKpzhga0PYoeWYqUunTGbTRzFd7OXdlCPVT7I7vuRFQA+QF9Lm69KmZLKGKgkt4fzb1&#10;YRGV1R9HAWsHGSONFRWRNRQBOYluAG9M5n5YAr5GguJz8o9CN43kUrQLNRQPVXs5t2SVcujmBfIv&#10;1xkHDqLSp9zmfUBZvnoJN/E2mUUkwk/hg5mpD4sogHQCuFYUhQVxpOmiArQhnUGK0j7CZqOkiZlv&#10;otKnGZdhDJw0T2E3+a5ZKyiyfgxtMrkfgseAp1H2J7d+ioAOmKmJ16UxDSQ+I0vI2OAodmk09WGB&#10;cuhd7lnpgZLrBr0p9JRAXQSOoGyFo15mI8yhDe9d7Pg0cGLp0wgSFQ+hjEWO61Y6BJ9C90zuDKHP&#10;cpL8hggmS/DLaO2+gdfsprKGxPhpJB5dTWByJwnhL6hHVnqg5Lg5byoxLTWDylfeQW4iHoZn7pW0&#10;gBynHhHoprHe+nSK/NatgATFF/E96/UlhDCMnLTSfIocy8lST8UM9n9vLPF7vYGqCS7gEiiTN2so&#10;2PEFqly4hrOoN5Hb5twvFpBjzztEJ5FqL8fUhBW02b2P+nIWq72cVlKgxuyp+Bohr1KdxGVkL1iH&#10;Up1xZM37EJr9kRtdtEafR5u2aTBFUaR+pPN4jTV5E1DZ01eo1NWudOtohaiI2YqrwJdIVFyv9opM&#10;DUiR0o+APwLn4+ZnBk9vqU6OEes0aPMU2mRyvMZehtHnuY88RcUqKns6gyOBbWERPT+z5PmMGxNQ&#10;puISulcvkXlWugpaISoiy6iM5RgqUfDCZW5H6sU5iUTFEdxLURUFOgTvQeVPuRFQwOIc6qWowwE4&#10;9ansIE973jT07hI6bHqtbj7zyFnvBPXoSTLto0vZ/3MWnQns+rSONomKlK34CtXHOyJibkcXRZ4/&#10;RqLC0zKrIx2At5JnPwWoFvwoEhZZR65i4/skEmlTSLDlxhoK/FzD9s1tYQGJik+RmDQmN9IE+GPE&#10;rDQ+Q36HHDfoftFFEZCvgQ9QRCTrA4CpjGQjewT14vhgUx0dVKozgQRGTv0UKaN1FUWurlCPyNU0&#10;8Aj5WclCOWX5W1FR7eWYAbGCnqHjKKDjII7JjWUUQEqlT8s+F3yX1oiK+OUvoxviQ9S979S6WU+g&#10;rO89jhYP91JUxxDl0LscD8BLSFRcBRZz32Ti9U2ifoqxii/nVqR5H+eAWQ+Vag1d5AJ1DomKVbw3&#10;m3xI5hFnUa+XK11uQ2tERSTZyx5DUWiXtZj1rFKWPn2BDotePKojZSq2k2dT8RJyrblY9YXcC7H8&#10;aQwJizHy2wNWUJbiG2yo0SbSoe0cepbsAmVyYpVyuOlZYCH3AFJV5Lah9JWeYXgXUPnTFRyFNjez&#10;jBaNz1BDllOc1dNBPRWT5JWtSG4g59E9k/V90tNPsQ3ZyuZoz5syhWex9Xdr6Nmbr6PAn+vVTU4s&#10;o6qF47h64Y60SlQARE/hWaQ4P6dMtRqTBjF9gxpvPeyueobRwbdDngfgJXTPLFKPrOcW5Pq0jTyH&#10;3i2gNXkW97y1jS4SFen7r8PzZJpPGniXnCBnPJvi9rROVEQWUKbir6hx2xZ2BsrF4wNkJ2sb2QoJ&#10;IXSQ5ekkeR6A0yGoTs3EyUlrO3l+ptfRszePD5VtIwX8zqMqAn//JgduoCDj31DA0eeCO9BWUbGK&#10;Fq53kfq8Uu3lmExYQSVPbwEX3CSaBaPAXtRPkdshI/mWp/kUuWe1UqZnDNnJ5pb5AYmKNKsg98/T&#10;bD7zqLzEDlAmFy6jqpYv0VnRGdQ70EpREUta5lB93CdIYHgDazdpgvZxHI3IhfRM7kA9ALkdMgI6&#10;BF+jHvX/aebHeHzlKCoWiDX1FvWtI/VVXMOZCpMHAa1H3yDXJzdo34VWiorIKlq4PkXZilPUw2Pe&#10;9IdVJDB/j9xH3GdTMXHxDuggnHorcqODBMWNGmw2BSp92kaen+c8Kn9ZwM9fW1lF98BVfA+Yaumi&#10;rNmXlFkK35N3oc2iIqDN6xgqd/k0/jz3g4HZfLqo7Okd4D1grgYHxMYTQhiitD0dIr8egDV076zW&#10;KKq+FQ2/y63xPa3HM6iGuS6fp9lcVpG4TL1KXodNFSQXumNortnXaF1y9uwutFZUxEPjKlKiH6Js&#10;xQzezNpGKoX7AHgf2Q37HsiDYVT7P0x+a1UapjkLLEe71twJqOxpgvw+T9B6nMrJvHm3jLgnryEx&#10;MR9fXotNFaRhjF8je/mz2F7+nshxYxkY0RZsEbmNfIFKoDxlu12k5uz3ULbqmu3ismEIHYJzLNVJ&#10;ouIsEqW5ZVFuReqpGEMN8Dl+potIVPgw2U7SELxrOMhnqiPdh8eRccQMPhfeE60WFfCtsJhB3f1/&#10;RcKiThaR5sFIkzKPY8enHOlQCouc6MTXFWpgSR3tebcge94tSFjkJCq6qPzpOh581lpiJHiB0gFq&#10;udorMi1lHs2k+AJVL6w6S3FvtF5URBbRofJN4GPsPNEWkqD8AtVOzlZ7OWYdAX1HW1CEPTdSpnOJ&#10;/COqBcpOJOen3KZp9zpprWJR0WaW0H1wCdt3msGzDJxD5dBf4yzFhsgt+lcJRVF0QwiXkaA4AOxB&#10;B5ntlV6Y6TddJCDfRZZxi9VejllHQAffKXQgzok1yina3ZpEsQrytZMtUMbnetUXYipnFdWzX8ai&#10;wgyeG5QN2qexjeyGsKgoWaIcfPYQsBu5pOS2+ZrNI01E/gK46oUjOzqUcxVyW6uSS00SPnUgoGBJ&#10;joMEQRHCJeoxSND0jzUkMF3+ZKpgBpU+HUHnAtvIbgCXP0Vib8V1dCN9iJq3V/Dm1mQuI0FxEffR&#10;5MgIylKkMqic6KIDT+5lT70UaEbFVvISQsmJbxHV09sso9100Xo8h0WFGRypn+c0OhecxdULG8ai&#10;4mZW0dCdI2jYyXksLJrMZWQX59rdPBmhPADn+Ax20X1TB2GReipSpiKntT+gQ+QCyv4s2oGt1aSm&#10;/TSp3veCGQRraGr2Byiw7HPBfZDTxlI5sfxlGSnVdGPN4EWtiXTRpnUKmLXrU5YkS9ncmopB11Og&#10;w08dNp4CCYpkJZvb2r+KhMUSnlrbdpKouIT2X2crTL9Jcyk+A94GvgLmXRK9cXKrU86BNVQO8z7q&#10;rdiLDjZT5HewMfdHGnh3ETVqe9PKmxHymwORRMU8sBJCKDLfgDoo65Nbw3siZStWyE/wmAFSFEUI&#10;ISyitfkKKkEZr/aqTMNZQiXv7wGfoIoVBxrvAy/e6+jxyT6Bmrb/Gn+8UOV1mU0loNKnI8jloQ6R&#10;5jbSRVHrHCdqJ1aAlcwFBZTOTylbkSNzKFpY1GRCuekfyQHqCt57TX9JZe8fowqV08BSDdb0LHGm&#10;4hbESMksSoH9BWUsdqIN2dSfFGWeRX7UjkhkRjxUFkhYDJGfqEjN48Pkl0W5HV009C7XqO88OkgG&#10;b+itJ000vhzfjekXyQHyLUonSJe83ye5bdTZUBTFClrQPgE+QlMVTTNYQ4eXWdwUmjM5R6tTk/YY&#10;eQ7mW08HfZ5j5JepCOiZXKY+je+mvyQHqBnswGP6SxIVH6JGbTtBPgAWFXdmEdmKfYTcoK7ipu26&#10;E9DB5Qgqa8OlFvnRE6keIs+5BUlU5JhFuYl4fw8j16dR8rzeZfSZ5ur0ZQZLMk2ZxeVPpn+soN7K&#10;r1BPxQ1nSR+MHDeXnOiiRe1j4P9DrgBzeNOrO12UgfqEetTDt5UOiqyvkWf0OlCDtSDe3x3KyeS5&#10;XXMqdVnFe5IRyQHqAtqDHcwzm00X9U+8i4x5LuL+ygfGPRV3IPZWLKNsxTvAw8ATqNxhjLzLM8yt&#10;6SJheB1lorxZ5UuyPl0lv++pIE+r29sRKNes3D7L3jkVdmIzoHt0EdnKXkOHvWSHbMyDkoYdf4Z6&#10;KY5gC9lNwVGhuxDr7ReQS9CbwBuo7s6Ktp6sAEdRg7ZrJ/MmlRjlKCrSDI1hoFODErpAnta8iWTP&#10;60yw6Z0ZNYv6KlwCZTaLgATrMeBvqLzdg+42CYuKeyAKixlULvM/UDnUVbz51ZEVVDt5CtdP5s4q&#10;cQ4E+T1raUJ1h7IJOmdSX8VYfM/tejtoo7fTj0msIZF5jegKVu3lmIawikx43kMVKCeQYYvvr03A&#10;5U/3SFEUqyGENBTvMWAPanycJN/on/kuaeFYxNGv3FlBh4rUwJsTqTQrWcvmThI/Y/GVE13s/GS+&#10;S6oSuIpKVXzoMw9KGnx7FPXIfo4NeDYVi4qNsYQae/6ANuZV4HlgOxYWdSA5P60Bq45MZE/KVORI&#10;OqQPAUXOtsSxNCv1f+ToVtVFkehl8hOPplrW0Bowj0WFeTBS79YZ1Jz9MXAeWPZZYPOwqNgARVF0&#10;Qwg3kLodoYz8vYSyFiZv0qKSGv9M3iSv+lVKp6WcDp0d9Nznvo520Ho1Tp7Bj4BERbLoNQbKINB1&#10;dH8Y8yB0kZvYhyhLcRyYs6DYXHLfDLMjlkFdBT5Fm/RuYC+wn3q5wbSRVKN7GpgLIXRyjjAboCyN&#10;ya0sJgmcSfIbJncrhoBpdK1d8stWLKLv2OunSaRm7RlsK2sejIDuoS+Av6Lm7MtxyLHZRCwq7oMo&#10;LC5T3qB70We5D3+mObOKFpZTKPpl8qaDnqdUspbjgXML+U/UTsMDt6PMam6RuTRR2z0VZj1LKEsx&#10;h9bvOgh4kxfJ7Sn1UbyDzFo8qb0P+AB8/6yierx3gG3Azvi+lTwPP0ZRrytIUCyT3+HK3EwRXzlm&#10;KkDR/zSlOlvivJ01tN4Pkd/61KWndt7lCCYSKO2k049zK4E0+bNC2UfxFvA1Knty5qsP5JYCrw1x&#10;45sHvkHq9010s9r6Ll9Sjf4a0PXhJXuSs9ICOlDkRG+fwmgIIdu1NF7bGGWTdk6HsnRYLIA1lyOY&#10;daygoMJSfPkgaDbCGgokfoTOaJ8CV4qiyG0/aQzOVDwAPY3bX6OheNtRpuIx8i+JaCuppCangwZ6&#10;K7AAACAASURBVJW5NenAmYRgTiRHpSHKDECuB54R1PuRBEVO934qfVoFuiGEwmLfwE0Ztt5Bkznd&#10;uyZvAqpK+BqVqX8AnCmKYrnSq2o4FhUPSFEUa7Fx+yNgB2rc3oLmWLhxOy/SALDk3GXyJh04U/lD&#10;TiRxCjr0jIQQcrUpToey3LIUiWQpu4qu1VFEkwjo3t1OKYyNuRvJ6fEUmpqd3J5ytShvDBYVm0Pq&#10;r3ibclP8EXCAzOutW8RNEdGKr8XcG8n5KUdRAaVATVOqcyaJoNwOZUnoXEONkzmKHlMtnrRuNsoa&#10;pX3sm8hUZzbToE+jyH0jrAUxTbuIHAWgbDz8GfAo3ihzINXmX0NR0dzKacx3WUPf2Up85WaFOoSy&#10;khPkPV8hrUej5HmdQ+h7XiJP8WiqZQbVxfveMPdCF7k8fkaPfSzOgA4Ei4pNIvZXzKHG7YA28GnU&#10;Y7GdvA5DbSVFvheBNddvZ88a+q7SALw18nqO0pyKXIfKJVLD+xR5Zk5X48uWsmY9HbQG3MAZZnNv&#10;LFDax76LSqCWvNcPBouKTSQKi15HqB0okvl8/LF7LKojlX8MUdbpm4yJGcAkAlMZVE50kKiYIC+x&#10;cyvSteYmKlZRaUsXCN74TSKEUKD7Nk3WdqTZ3I0l4CylfewR4IbtYweHRcUmE4XFArqZ/ydaDBeB&#10;lymbt83gSRtUgQ4wtpStB2kKeo5zRQo0myZlAAryu0YoG7VzDGikEjdnKMytSPdsb39V7gLeVMMa&#10;cAm5PL2Byp+uFEXhtWWAWFT0gR6r2a/iL3VQxmILKoUy1TCMorVT+N6vCwHVx6Zodk6k8qdtlO5K&#10;uV0jqJE8lWDmJnpsoGBuScxUdtG+OYnuk9zuX5MHAfXdvA/8OxpKfA4JUTNAfLDqE1FYzKKMReqv&#10;GEGlUNPkGTVsOsNog9pGfmUgZh2x/KFAgmKR0gUql2enQAf2LURRkWmfzggSFUn45ETv1HSLCrOe&#10;lJlI90huz5apnjSI+Avgz6js6SQwn+Fa3HgsKvpIFBYzwJdoQwdFW15AwiLn5s4mkspAcm+sNTez&#10;QJ6HzjQAb4LSASrHidBp+vcE+a35vcJxJVNRZqojzRuYQ+tAbmuAqZ4l1Jj9BvAX4Bjuo6iM3DaY&#10;xhGH411DtmZrlIeOV5AzlBkcHUpbzVyi3ebOdCkzFan8IZfvrkD301bKkroc+yq6aN1JRgU5kZyp&#10;5tDhwJj1zCNb2UXye7ZMdaQ+m3PAH4HfA58C1y0oqsOiYjCsAlfRDd9BB5DdwGPk20DZRIbRZ5+j&#10;C465NavA9fjKbY5BmtC+DQmL3A7sqYRsiHwnySdnH5snmFuRjDWS3bDvDwO6D26gMqf3gP8APkZz&#10;qNyYXSEWFQMgbpQrIYQrSFikw8cvgWdQKVRum30TST0VY8BICGHIzhD5Ehs1kztQimTndqjoUJbU&#10;5Ugq0RojQ9FD6f6U3NmMAW4SxMkAIYlP024CylB8g3oo/oAatC8CKw5MVItFxQApimI1hHAJPQBp&#10;oM8cat7ehe1m+80QqiufouyrsKjImzW0gcyhZyYnUj/AODq0p0bynAiUwif9PCfSnArPIDC3okNp&#10;hjCGhafRWnEOZSj+F5qafRYPuMsCi4oBE4XFFdRjsUxZL/4iKonK0aGlSYwBO1G5ygi2nNswIYQ0&#10;SHCN/pespEbN6yiinRvpwD5Gfgf2lO1JvR85ip4uWv/myLPJ3VRLgQJBO+PLZ5Z2s0ppHftGfD8L&#10;LFpQ5IEf0AqIzdvXkSvUGhIWV4FXgUdRJN30hxEk3nYAoyEE285tgCgoptEGfx01UPazwbaLxMRV&#10;lNnLjRRJzTmKmkRFjnMqUj/ZLPllokyF9JQ/JoONZIRg2st14EPUQ/EmcApnKLLCoqIiorCYQQPy&#10;FtHDkgb9WFT0jyEkKJJvv9kY24AfAz9Bi/tfgDN9/jtTs/YN8jsUJyGRmrZzdH9KwidHg4JUN7+M&#10;MxXmu6TBiKvo/sjt2TKD4waaRfFvqJfiKDBnp6e8sKiokJ4BecfQpjpM+Z3sJ78DQBMYQlH2XSit&#10;bu6BEMIE8AjwfeAfULleQI4bff2r0YHiRnytkk/EMh2Iu/GVy3WtJ8TXGPldX/rsIL9rM9WT7gmL&#10;ivayilydvkI9FH9EQ4WvO0ORHxYVFRNTvPPIGu1PlPXFvwAOoMxFrmUVdSRlKvbF95M4QnpLetxX&#10;poBDwG+Af0RleksMruQniYpUIpPT4bhDGU3N9TktyLcReg3dS2mGRq7XaQZMXH/GUPBnnHxFu+kf&#10;qYfiQ3Q++iMqG79hQZEnFhUZEIXFIrE+EB2eZoGfA0+hkhMPbNscUk/Aoygb9FUIYc0p1JuJG3rq&#10;P3kWlTv9GjiMmtwvouhRvxvdU6biOmVfxRR5HeADOhxn5yQWQhimtJPNcRNOcypG0H7kAXgmkZq0&#10;dwMPYev1NpGyq9eBT1APxR9Q+dOsreDzxaIiE3qExXlKm8VLaJbFYWAPjtRsBh2U/XkYOIg2qkXs&#10;AvUtPW5Be4HXkJh4HXgClY6lBb3v5QjxuVihnKp7HR0ycrFfTtkc0DXmJk7T/IdhtK7kNJEcSkGW&#10;47RvUy2pT2kryipPYFHRBtIcitRz+h+UGYoZMgzemBKLioyI6bylEMJFFLGbQ84388BL6CA8SV6H&#10;grqRUurPAK+gtOpMCMFDc0omUCbnB8CvgB+h6e+TlAe/FP0eCiF0+pzpSQ5QMyhbcZA8JtGnKPsK&#10;el6XM7yH0hTiJCq65Hl4z+1zM3kwjPrfdmFB0RbW0ByKD5HD0/9CguJaURQuj8wci4oMKYpiJYRw&#10;DaX6VihLP15Bte3T5BOprSPDqF/lBeBJ1Cjf+gFcsVRmCgmIn6MMxSuoTKz3ED8Uf55KVtLE275d&#10;Gvp+LqJM3pPcLHCqIqAs1zl0bbllKZIZRJfSTjY3UdGJr2Va/vyZ75CyynuQqKg6iGD6TxdVaLwH&#10;/DsSFUdRU7bXhxpgUZEp0XJ2ltiUhB6088APge+hhTZ5z5v7YydlSc9VWnyoCSGMoHKn76H+id8B&#10;z6Gyg/X9PKnfYuQWv9cv5oDTwHEkBtN1VUlA1/U1Eqa5Rtt7xU5uB7M0g8AliGY9Q6ifcCf59VGZ&#10;zSX1zs0A76KSpz8hl6d59zzWB4uKjFnnDJWExTngAuWgPLtD3T/TSFQ8ApwNIbRyKmcIYRSV1v0S&#10;+C26tw6hWubbHdyH0b3X9zUkPgcLaHLqEZQV2I9KsKpkFYnR0+jZzHXjW6WcRp6jqBihbMw0JlGg&#10;NXoc19E3nQVkVPMu8HvKDIUFRc2wqMiceMhdjH0Wi0jJX0IHqx8id6iduBzqftiKPr9X0AC3ecrD&#10;V+OJ07G3IWH1IyQovo8Ext3sYocY7ADBZC14HH1Xz6DvryoCEvofoixFzvfNKsqo5HgwS/MHOuQn&#10;eEy1DKPs6U48s6nJLKPA6RvA/wT+hgSGB9vVEIuKmlAUxWrss0jTty/F14+B59HcBbtjbIwJ4HHg&#10;p+hgeL4t2YoQwhCKAr6AxMQvuLms7m6kBsqBDBCM2Yo5JChOUbpAVXW/L6KN8C107+Tc6B9QI3lq&#10;2s6J5HTXwXMqTCQGPCaRqNiN1hmLzmbRpexJexsJijdR5rcV+3ATsaioET22s2dQlPQKKoW6yM0l&#10;K7aevTeG0Yb1MvApSrfOhBCWmhohWTd/4mXg7+LrGTa2cafJ5IOcSr4MXEYlUCfRv2GKanor5pCR&#10;wifAhVybCKN47FC6VOV2Xydnr2R9awxobZ6mnE/hs0qzWENnmG+A95GgeAudbSwoaowf1JoRH7bk&#10;DvU5Koe6gJq4f4QGlaVos4XF3UmH45+hmv2rwMkoLJq4sI2g8qa/A/4PdM9MsfH7JUUSB1aWEJ2M&#10;ZoCPKAX0s1Rjs3wdlWKdRZH2nEk9FfOUg+ZyWRuSLW9u8zNMtQyh5/sAEhWmOayg4b5H0UC7P6M1&#10;3YKiAVhU1JToDpWauOdR1uI8EhiHUfOxHTPuToH6Al5EadgTaMG7TMNKMUIIUygj8VvgH9Bgu133&#10;+b9bRgJsicEeBueRI9pfUWnELiRsBllzfRX4GKXqz6JNMle66Prm0X29RJ6lJKvk2fNhqiGty48g&#10;pzfTDNbQmeVDtIb/FWV8L5PnnB+zQSwqakzPsLzzlMPBLiLFfxh4GqWPB1miUkdSf8HL6JC4CLwX&#10;QriUa1nLRoh2sVvR/fAr4J+RiHqQCOAaitavMcDyo9hbdBmVqz2EmsULJDD6PRBvBQn3j5Dl4fvA&#10;TM4bYSyZXKXsxVoir76KIWQKsEje4swMlmGUgZzEJiRNIGUnzgHvoAnZf0PlTzNFUTig0BAsKhpA&#10;zFrMoI35KooEHEGlLa+haE/qtTC35wAa+JYmJH8QQrha1/6K2D8xiqL5z6OG9F+i5uxtPFgWK/23&#10;I/HvGKT70RoSzm9RlvK8TOla1Q9WkOD8M5rw+hfgbFEUdTgIp/Knmfie0wC81EuxXNfnzPSFCRQo&#10;KND9a/en+tJFlRSfIiHxFspUnAQWcg7KmI3jQ2ZDiPXmyUlhFkVUTyInhR+hQWZ7KSfYuizqu0yg&#10;2R8/RunYeeDzEMJs3Q480T1lDPXXHAb+HngdTaPexoMfKpNbzygwFEIoBrU5xOj7dTR0Ll3LCMpU&#10;pHt8s0hTqC8hIfH/oE3xNPUZ1rZC2Xs1iw5pOUR/06T0KzSs1DARhT0+OG2YSWR1vZX8SvXMvZHW&#10;zmvAZ2hC9p/Ruu1yp4ZiUdEgepq4r6MDT0o3fo2Excsoar2PcrH2gn0zk6jvYI3SO/+TEMKNugiL&#10;eJCZRBmql1H25SeouXmSzYlSF2j9qGS+QBQWN1CzX5rK3EH/3t2Uk74f5NoCpUD/APhvSFCcol4R&#10;thVUFnkEZVsepf+lYvfCGvos/4RET6OIwn4Yie7GOsptNj1214+ifoocBLDZGMnG+gpyyPt9fH2F&#10;RMZqjdZPswEsKhpIT9ZiGdVRX0RZi89R9OcwOjjvxi5R6xlCG9mL6LOZQpOjPwkhXM653CWKiQl0&#10;/U+h4Yg/BV5CE6i3bOJfl/6uISqq0Y9lf7NINHdQac9FdG+noVmT3N86l6xOP0YZirdQLfA56udQ&#10;soo28mMow3KDPJpf00TyE+Q9PPB+GUU9P1vQ575U7eXUhgm0N+1kcMM1zebSO8fnDbR2HgFmm9Cn&#10;aG6PRUVDiYee5BB1Cm3ex1G0+iQ6HD1PadnnaFBJmhb9MioVmkYZnvdCCGeA+ZwOlTGyN4Ku9SAq&#10;dfsBZdnbNJtf7pYsH/vVw3BP9PQTfYqyCidQQ/ozyG42RTuTQ1TvmreGxMMaOuAuxddc/H9dQP0T&#10;f0COUzN13BBjkGEB9aGcRGvBfqpf/y+gTNMszXR+GkV9PgeBxRDCeTek3hNT6HPbh3sp6kbqnziK&#10;hMS/of6Jc9Qru2vuk6o3FdNnesTFdRQNvExZEvUK6h9Ik5THcb9FokAH5qdR1Gw/2uTeAI7Ez3Ot&#10;ykUylleMosP9HtQv8QrqnUg9NOk73Ww6SKxsoSw1qipj0Y2lUMfQQfUTJCZeRE3ph5Ao3Is+qw7K&#10;4i0jEbGAMnoXUHnQ6fj6Bm2OF9CGWOfylVW02X+DyrmepvzeBk0gOqwh0dZE++aUyTuExP0q8G4I&#10;4WLN76NBMImE2NNsbnbV9IcUmEm9W+8gd7y3cblT67CoaAk9/RbJq/4yiup+iQ6hL6Ma/O0o4u17&#10;o+wb2AX8AlmYPoamf74PXAohDNy1Jh5Yhigjes+hw/P3UNnTIfQ99rO0bQjdJ8nysdISuthjsYQ2&#10;tuvo/j6OfND3IZFxAImKdKhNsxGW0GZ4Lr4uoej5DeLAuAZsiMkC+Gx83eC7mZtBXstR5ATzBZll&#10;/h6U+HwOo2fzNTRoch+6394IITTq37tZxM9tBGUWd+PseR1IZgvnUMDiM1Qu+i7KjM7VMbtr7h8f&#10;HFtGPAAvhBBSv8Ul9PB/joTFYVQ2sh1nLBId9Hmk2Q4PA4+jQ9GxWH6zNIjShhDCMNp0U5nTD5Gg&#10;OBB/fStlr0M/SZHYKfJo+v02K4cycyvo4Jyyctvja4JyivNq/PEaEhk3UOnTUvy9blMOfz2i6xjl&#10;4MBX0eFt0PtAoBR9Z2hYliIyjtaJQ0jQ7kX/3m/QmtEEobrZpOzwM+jedOlTvqR1cw71SryDzCw+&#10;RwGD82hPdFauZVhUtJRYi76AopYpSjuD0s0HefA5Bk1kCyox2omyOk+gEo4jwIUQwiXg+mZFZnoy&#10;EqPo+9iJypweQ1mJw0gI7mPwcwcCKhtK0cXKRUUv8cC2Gl8LIYSraL1La17aFNPBrguEJh/04jN/&#10;GpUl7ESCYiq+BkVA5RAfo9KIGw38zDvoOX0aPatT8ec/Qz0ty/G9iWLqQUiudYfQOutMRb6kQaBf&#10;oWbsvyBBcQEJDZc7tRSLihazrpn7CmrgXMF9FXcilUOloYKHKaMznwAn4gF2AR0eVtGBFdZFvpOH&#10;PeWBPFmgJivKCZR52IuyRy+iQ8ohJCR2IKFTxXe1ipyWkrDImp7yv9Wen7eOoijmQggnUFTxCZS9&#10;Ochgsk0rKEPxAZr38Rnls9EkxtAz+gJ6XifQM/oKKqubQett42x0H5AOKjF9CH2G2a8rLWMN7WnJ&#10;Ze89ZAf9N7T/XaMZpaLmAbCoaDk90fBdKDr0JIqseUG/PR3K8oadyLL1CjoknUZuW5+g0o6rlPX7&#10;S7HsbA19vkPxlQbJjaDNdAId9h5GpRNPoYzEs/H3Ui18leIvRfqJ11CLjcQbHqDD7IfoPlpDtsOP&#10;o3urX8/9Kurh+iMagvU+DcxS9JQnPooOx0lQFCgz9BLKbH4eQlgsisI2s3y7D42hz+cFlJn1HpQP&#10;yejhKOqD+gLtcZ+jaod5GlQuau4fiwrTQQv4s6g+/ykU/faCfmdS2c8IEmGpuXCR0mXnBuVU82Sb&#10;OULZTLyEDuMddPjYicTdLlQusTe+p1/fOpB/2b2RhNUUOgx4M6kPK6hM4V1KB6gRlLnox57QRUL7&#10;fwH/N4psXmioveoYEhPPoCzFtp7f66AM4+vo85hHfRam3IcOonXP85PyIM3ruYBKFv+KMo3HUbYi&#10;9RN6/TeARUWr6YkOPQp8H6Xn7bpxf6SyKNDB4fH440to8Z2PPx9DYuIa5TCs3lKn6fi+FYm7UQbf&#10;L3EvdFD98zS6dlMTepq2z6ED/hjlkMd9bN6+0EXlEleBPwP/HdVfN1JQRIvnaRSgOYzME9bPcZlE&#10;/VC/A46HEK6gPqy2H8om0D70BAqiuPy2elZR8Os4yiy+Gd+PIzGx4kZssx6LinaThry9hETFIey4&#10;sRkku1fQQe0Rbt4k03yEZD05wneFQ+5RuuT+NI0OSkM0c4BZI+kRFqeRc0sqhXoFRYq3UM44ud97&#10;8Toq9fkI+G+ombORgiIygoIyL6Im7e23+DPD6ND8CmrcPg98EkJo7WCwHjH2PSTIdt35vzB9ZhmJ&#10;hovcLCg+Q/frfIOfYfOAWFS0m3F04H0Npetdx7r53CriNkqZDUrN2XWjQPdPyqyM2CazXkRhsYwO&#10;/jOoVO8DZFX8DGUj9wiluOi9V0PPe7fnlSaUfwz8X8D/QP0UTT+MjCFR8ShaS2+XYRxGZY2/QY3r&#10;14CTIYS2lpGMUbplHcCZzypIz+4y6pH4G3KJ+wTZUF9EQQKv8eaOWFS0lNhQuBMt5IewoBgkdRUS&#10;vRRIHE2he2cc1d56w6kRPa5YF9Ah4jgqUXoa+AEyCHiIsiQv1bp3UW9Gmkh+DdVdJ6OC00isfAac&#10;bElD8k4kxh5H2bvbPeOp7PQ5JCwuAX9Axg6L/b/MfIhZiikU3HqWm3tQzGBYRc/vadSI/Snqt0qZ&#10;iTlc6mTuEYuKFhJ7KbahSORryPEppyZgkz+pdGsrimZPomi3N54aEjMI10IIN9Dh9hjyoH8TNc8e&#10;iu8j6OCbLJPTAKyLSEx8gyKdqYlzseHZCQBCCCPo8zmMMhV3i7anxuQXkaiYB/4aQjhbFMVyP681&#10;M4aQaH0JCbJBzkxpOykwcBG5wb2LsotHkMC4Aiw7M2E2gkVFy4iCYgTVTb+EopH3sgkas55UC70X&#10;uV+dq/ZyzIMSBzeuxsGY5ykH5R0C9sc/NodERbJGXkbuZlfi+xKw1pbDSIy270KZh5fij+/V7GIP&#10;ct2bi6/FEMKFNnx2cS+aRp/bjyjnpZj+E5A74SkkKP6ASp5OoGd4GVvEmvvAoqJ9FCga9ARqFnwK&#10;RZmN2SjpULAf1ZLn6FJl7oOiKLqx3wKUeThP+f32Nm+neSVrtGAq+W0YRevoa2hdXe/4dCeS69FP&#10;UWZnFk2Ab7QjVBQU4+hz+wnaizwfaXAElKF4G/U8vY2yE4u08xk2m4RFRYvoyVLsB15Fm+AOfBg0&#10;988YKuOYxjaQjaLnYJFEw0r6vZ5p8K0eKBhCGEIlgM+gnoA9bHw9TcLil6i+vYscuZrchzKMmrJ/&#10;BfyczbUyNncnufeNUmYal9w3YR4UP8TtooNKGV5F6WZbyJoHZQgJizEsKlpDm4XEOlIp6TPokHw/&#10;M346SJh8L/54DZgJIRwFGmc1G4XYLjQE8NdIjG0ku2MenAIFFJ9E2bW/Ud57xtw3FhXtYgxlKV6m&#10;dNrwQdA8CMOojGECryemRcRsTRIDL6Asxf0yjA55L1BOMf5/gSMhhLmGRZC3As+jAYCHseNTVUyg&#10;PpZnUbP8BXqykcbcDz4EtITYTLgV2R0+jjIWLnsyD0Iqp0uTwMdDCJ2GHYCMuR2jwMOoJ+B5bj3s&#10;biOkfrfDKACU3LWOhhDm656xiCJsAkXGf40+t71VXpNhEtn5PoLsZOeqvRxTdxylbg/jqG71WVS/&#10;a+s+sxkMo+nLvZO1jWkDW9E8j9dRpHczmowL9Bw9Bfxd/H8fRIK9tk3M8drHgMdQH8XvkCBzYLNa&#10;xtH38DSwJ4QwWuf7zFSPH+gWELMUaS7Fy6j21zWsZjPooOhjmqw9jFPopuHEg9dOVJO+m83tTUsZ&#10;i9dQpmIM+CNlKVStMhZx/5lA+84vkFh6FgUjTLWMoLK9V9D07AvIGtq9Fea+sKhoB8OoMe4ZlKbf&#10;ibNUZvMYQ6Uf2/CaYtrBJIq6v0B/nM/SULjX0eF7G/B74MsQwtW6DBSM4msSBbR+hDIUr2K3uFzo&#10;oLX7ZeB94GtgNoTgGRXmvvABoOH01LHuR6JiH85SmM1lDB0SdmA3MdNgemy5DwHfR4exftlyd1DP&#10;wY/i37ETCYsPQwjnyXzaccxQTKLSmt+isqdX0L/JgiIfxlBJ9PeQC9QplG3O9t4y+WJR0WDiBjiM&#10;0vNPosjaCFosXDdpNotRdOjZgwWraTZD6HD/QzRf4Qnuz0Z2IyS3pN3o8PfvwJ+BE3HyeVZR5bjv&#10;pPkdz6Jyp39FQa2tuO8qR4ZQedqjwGeoYduGG2bDWFQ0m5SleAx4CW2A41hQmM1lFJXXPYzuN2Oa&#10;yhgK0PwUZSkm6X/UPa3jB5Br0j7k1vMfwOfA1RDCag4lUT2Z8QPoM/ot8AN0WJ3Ee0+udCgbtj8B&#10;LocQ1nISq6YeWFQ0mw6KID8PvIjSzv2Oqpn2kRygtuFMhWkoIYQ06O511EQ96DKeYZQN3ILq4B8C&#10;3gA+Bs6EEGbRsLyBi4s40G4cBReeRkLiF6jc6WFc7pQ7Bbq3XkR9FceBRdywbTaIRUWzScPunkGR&#10;rQkcKTKbTwdlK8aQ9eVwURSrFV+TMZtGjMBPo0PXr9Gsn6oCNJPAc+gQ+BjwNhIWJ5G4uILKV1b7&#10;HWmOfRPjKHh1AAWwXgd+jPYcD1itB8kh8lnUSP82cBUNYTTmnrGoaCghhGG0CT6GhMVkpRdkmkwH&#10;CYrJ+BoFLCpMkxhGJTy/QWVPDzro7kFJWYufoqbx14AjwBeoJOob4FoIYQ49i2uoRn7D/Rfr5hYU&#10;6HkfQs/5NJqjkZwFDyPBkwxBHMSqD6OUs6weAb4JISy6BMpsBIuK5pKG2ryABintwAu86R8jKNI1&#10;jQ4T89VejjGbQzxUb0XuOD9DDdM5RN+HUCnUIVQKdRg4g0pXTsXXJ8A5YAa4ASyEEHrLWtKecLuD&#10;Y4dSRAyjfWUalX49hqLaP4h//zSar7EFl9nWlXEkVh8HPgVm8dwhswEsKhpIz7C7p1AE6yBe5E1/&#10;GaYUFeMVX4sxm0kHRW5fRFnfnNbSNKk62TrvRIf962iI2QlUxnIm/vgKsIzKo67G13L8/6x3ZQrx&#10;1yaQqJpGB86D6PN4HPVPPI57qZpCh7LCYS9wHosKswEsKprJMNpcnkZOJduqvRzTApKF5A7sAGUa&#10;QgzQbEeC4jC6x3PIUtyOccqG6YMou7IKXEKZi1lUBnUNCY3L8fdH46/fiO/JjjyJle3o2d6FDpu7&#10;4q+lckfTHCZRqd9+4Fic4m57WXNPWFQ0jJiqH0ML/+NIUNgX3PSbIVT6sB2LCtMcJlCPwOuoZ2CK&#10;vEVFIg3pG0YZhylUJpXKnG6gbEZAImQs/toZlLkYQWVMU/E1EX8tlUMVPS/TLMaQIH0S+BIJz+VK&#10;r8jUBouKZrIVpaefxN7gZjCk6bk7gC0hhI6jW6bOhBBGkaPRr1BD9EHqF6C53cF/Gu0TUIqErSgD&#10;kYaj9vZT1EFImc1hHJU/vYaa/o+HEFbcsG3uBYuK5jFMae+3G6emzWDooIjmw8TJ2nYOMTVnEvWl&#10;/TS+59RL8aAkwdBL6p8w7WYIVTg8iYT0JMpieS03d8XRhwYR63+3IEFxCJWi1C2yZupJuvceQfef&#10;M2SmtkRL7v3AL5GDnvvSTJsYQcGhfXjWiNkAvlGaRYEWgEeRqHA/hRkUBcqK7UX2khYVps7sBL4P&#10;/A7d08a0iXSW2IfExei6eSXG3BKLimaR0pYPoYVgHB/szODooPK7SVQK5XvP1I4QwhByevonbJdq&#10;2kmBSuH2o+xzXQwKTMX4JmkIPaVP+1GmYhf+fs1gSdmKZEHpLJmpFTEauw3ZcT+HBLLXHGDV2QAA&#10;IABJREFUUdM2knvYXnSe2EmzeopMn/Bi2RxSluIZtCHuxN+vGTyjSFB4EzJ1ZARlJ55FByqbmZi2&#10;0kHr+CFkwDHuEihzN3zobA6jqOTpJeTa4PITM2hSpmI7ypSNxwyaMdkTy562A6+i5uxpvIaadpOG&#10;6D6NzxTmHvCG3xzGUOnTk+hA54ffVMEIypjtxkYBpl5MognUr6NMxQReR027mUbVD4eRVb3Xc3NH&#10;LCoaQIwGp4F30/jBN9UxTDlEaweek2JqQAhhhNJC9nVU7mFBYdpOr6PkTryem7tgUdEMRlBk+Nn4&#10;7lp2UwUFEhUTSNxOoyF4XmdM7mxF6+ffo54K91IYI8ZQafUu5ChpzG3xZt8MJpCN7CPYdcdUS3Ih&#10;24XuySl8P5qMiVmKp5CgeAmVQRljxAil+cYWB4nMnfDNUXN6Sp8ewlkKUz0Fuh8PAo+hEihHfU2W&#10;xPVzH/Ab4F/w5Gxj1jOEgkO7kOB2kMjcFouKGhPt3YZRBOEJ1KS9pdKLMkYbzwFkRbgdC12TL6Mo&#10;Q/FfUB+FD0zG3EyBzhUPoyCR13NzWywq6k8HRRF2ogff36mpmiHK7Nk2nKkwGRJCGEV9FD9AAZkR&#10;3JxtzK0YoayG8LwKc1t8AK0/I0hUbAVCfBlTNaNI6E5jxxCTGbHsaTfwYzyTwpi7MYSelx2ocduY&#10;W2JRUW8K1KS9Bz3wTt2bXBhGpU/bcWTLZES8F6fRTIqf4LJRY+5GBz0z27EDlLkDFhX1pkAP+aPI&#10;+WkcR9tMHgxTDsGzA5TJiTHU7/Nz4PvoHvW6acztSdPm03rus6O5Jb4xakqMto0Ce5F7yVZ8cDP5&#10;kBxD9hCbtZ2tMFUTQhhGteGvoUF3j+JyDmPuRspUPIzOHJ4/ZG6Jb4r6kkqf9iGnnW042mbyoUCZ&#10;s714aJLJgBDCEDoYvQD8NL5P4XXTmLuR5g/tR8JiEp8fzS3wTVFfOuigtgtFg7fi79PkxTC6P3ej&#10;DcmHN1MJMUs2gaZl/wT4Ibo3nd015u4UKKO3m7IywucN8x18U9SXNKNiDJVBeXM0udFBpU97UYTY&#10;642pilFU9vRj1EvxJLY6NmYjJKvwnbjc2twGb/L1JUUOtiBbWVvJmtwYQlm0Z9B07TH3VZhBE++5&#10;7cDLwG+B53DmzJiNUqCyp91IWFhUmO9gUVFfRtBGuT++G5MbHbT5PIfsO+0aYqog9VH8DngVlT1Z&#10;UBizcbYgUbEXWYV7PTc34RuihsTI2xhK5z+CRIU3SZMbqY79UeBpNDjJJSdmYIQQxoAnkNPTL1AQ&#10;xvegMffHGBLlD+MSKHMLLCrqyzhyfdqDDm4WFSZH0qCx/ZRWhL5XTd8JIYygNfJ1JCoO4enuxtwv&#10;BaqQ2ElZITFS6RWZ7LCoqCdpBsABFP31g21yZgzdp7vjjy0qTF+J9rE7gZ8Bf4/Knxx8MebBGKac&#10;V7ETi3SzDouKepLsZLehximn803OpPkAaZ6KU+amb8RMWBIU/4gG3bmx1JgHZwidOfagMqgJ91WY&#10;Xnwz1JNhFHUbx1kKUw+m0YyAPXiCsekvU8CLwP+GhMXDOPBizGaQ+uR2o57OrfjZMj1YVNSTEbRx&#10;TuEH2tSDKdSs/STKVhizqYQQithH8SQqefo7ZBLgEg1jNo/UrH0Ql1+bdVhU1Iwe56edqJxkotor&#10;MuaeSKLi+8DBePgzZjMZQmYAvwT+Kzr4eI8zZnPpoMDQQfSMWbSbb/GCWz+SA8MU0Su62ssx5p4Y&#10;BfYBryCLzym7QJnNIjZm70CzKP4Z3WMWrsb0h1F0/tiFzyCmB4uKepJExQh2MzH1IE1jPYQyFg/h&#10;xlmzeUygidn/hLJhdnoypn8Mo2qJPThAZHqwqKgfBRIUO+LPQ4XXYsxGSBO2XwSeBbbYOcQ8KCGE&#10;cWQC8I/AD9A9ZozpHykzuD++D1tYGLCoqCPDaOjMfmAL/g5NfeigbMUrwA9RlMvZCnPfxN6cQ6js&#10;6R9Qn5kxpr8Mob6KA6is1ZlBA/hAWitiJGCYMlMxhQ9lpl4MA48Bh1F02fW45r6IWa49wI+B/4zu&#10;K9sVG9N/krXsw0hYTOOziMGioo50KCMCfohN3ShQk98B1FsxHUKwLbLZEFFQbEVZr98ikTpV6UUZ&#10;0x7SOv4oZY/ciEugjEVF/ShQH8Uq0K34Woy5X3agvor9OLpsNkA8uIwjh6dfAa+jPgrvZ8YMjiFU&#10;+vQUspf1Om68CNeQDiohsV2iqTPTwDPx5WF4ZiMMIzvLn8fXY3gvM2bQ9JZAPRJ/7Oew5fgGqBep&#10;p2IbivQ61WjqyiSafPxjNAzPA5TMXYllTzuBV1Fj9rMoQuq10JhqmEblrFtxSXbrsaioF2nw3Q6U&#10;dvRBzNSVURTh+jHwPdRb4fXI3I1pNI/iv6B+ih13/uPGmD4zRZxXgUVF6/EmXi8CylSMx5e/P1NX&#10;0jC8x1EJ1EPo3jbmlsR5FE8Dv0G9FA/hNdCYqtmCRMU0LstuPV6Q60VA31kXWMCD70y96aA63KfQ&#10;YXG7naDMekIIRRQUj6Eeil8h1xkfYIypnnFgFxIW43aAajcWFfUilT91kPuTRYWpO2PA94FfA8+h&#10;KdvelEwvo6gR9O+BfwJewILCmFwYQQN59+ESqNZjUVEvOigqsAVttD58mbozhA6MrwIvos3Jm5IB&#10;IDbwPwn8n8B/BV5CDaFe+4zJgw4qZd2FRUXrsaioCTF6O4QExU70APvhNXUnzRx4BImKJ4CtzlaY&#10;EMIQ8r//FfCvKKO1CwsKY3JjDJ1LpnAWsdW4frleDKEHdiuK6FoUmqawA4mK48BlYBH1DZkWEgXF&#10;LuCHwH8CnkfrnjEmP0bQ87odu1K2GouKepF6KLrAWpUXYswmM4VmDiwAJ4FLIYTFoijcN9QyoqCY&#10;Rpaxv0MTs7dUelHGmDsxitzYHkLP6pVqL8dUhSPd9SJQljwt40Zt0xyGUJTrKdSIewA7ibSVLege&#10;+FdU+rQTl3oakzMjwG60bu+0i1978RdfPzpITFhUmKYxjGwJfw1cAmaBEyGEZWcs2kEIYQJZx/4G&#10;+BmyjvU+ZUzeDKPs4h5gGzASQljzut0+vFjXi4JSVNhS1jSNNBDvVeAicBqYBy4gEW0aSpymPokE&#10;xS+A36KmfddnG5M/aebQNGWz9hI+o7QOlz/Vi+QANYy+O5eGmKaR3KCeRYfLl1A63Y4iDaWnh+IF&#10;4B+AfwYO48ZsY+pCWre3oed2DJ9PWokzFfUiWcruiC+LQtNECuBxNOwMlKX4IIRwpSiKbnWXZTab&#10;mKHYipy//gWVvh3CsyiMqRNpMO8UEhbj+PltJRYV9aGIry7lA+yH1jSVMTS74kfISWQJ+Bi4VuVF&#10;mc0jNnNOA08jl6ffoqnqY7gx25i6kQIE0yj46fNJC7GoqBeB0r+/izde02zGUF39b+LPh0IIHwDX&#10;i6KwpXKNiSVPe5CIeB0JiqexdawxdSX1xG2P766kaCEWFfUhoNkUS0hYLKPvz9EA01SGkZ3oK2iT&#10;GkX3/2chhOsuhaonsT9mO/Aa8HcoG/UC7qEwps4UKCgwTRQVIYTCDlDtwqKiXgT04CZL2QksKkyz&#10;Sa5A30MZugvAHHA8hDBnYVEvoqDYhYTiv6Cyp4fwWmZM3ekVFVvx+bKV+EuvFwEdsrp4ToVpDx20&#10;WT2DDqErqPTvWAjhhkuh6kEIIZWz/QMqaXsF2I/6w4wx9SY5QCVRMYLWbq/PLcKiol54ToVpMztQ&#10;ycwQchh5A5VCXS6KYrXSKzO3JTZk70XZpp8iUXEYHT6MMc2gQH1wW+NrHLiORUWrsKioF2lOxSh2&#10;fzLtI03c/gmwO/54K/B+COEisOT63XwIISSXul1ITPwT+u72I+tJY0xzSM/7JKWtrJu1W4ZFRb0o&#10;kKBItm12fzJtI/VYvIA2rj0og/E2cDKEMO8+i+qJ8yfGUYbiZeA/A79CNsFD+LBhTBMZRqWqKVPh&#10;wGfLsKioH8sonejvzrSVDkqzP4o2sH3xx38APgkhXLWwqI6YoRhH/ROvAz9HmYpHcP+EMU2mQGeT&#10;ERz0bCU+mNaLgBxw5pGw8ENr2swo8DAqpdkRf/x74O0QwtmiKJYqvLZW0jMh+zE0Hfuf0fyJfVhQ&#10;GNMGRlDQx+fLFuIvvV50kaC4jvz63Vdh2k6ByqBeQqVQD6Ma/j+GEL4B5u0O1X/iMLtRJO4OAz9A&#10;ouKnuAzCmDaRmrXdU9FCLCpqQlEUIYSwRikqFlDph7MVxkhgH0AC4+H4/ifgSAjhKrDiJu7Np6cZ&#10;ezv63J8D/nfgVTR/woLCmHaxBQUXpvD5pHVYVNSLNJ9iDriBHlw/tMaIDhITLyIjg2eA/0BN3KdD&#10;CIsWFptDFBNDKCq5B4mIH6HP/pX4a6NYUBjTNtKsiil8xmwd/sLrRUC9FAtIVPiAZMzNFGgzexoJ&#10;jIdQPf+fga9CCDNu4t4UxlCZ2UHgedSM/UOUrZjG/RPGtJVRlK0YA0ZCCIWDOe3BoqJepKF3c6gE&#10;yocjY27NMCqHmgJ2InHxB+CjEML5oiiWq7y4uhJCSAeGQyg78RoScM+gz3usuqszxmTACDBB2azt&#10;qdotwqKifiwDs8A1/KAaczem0cH3IWRp+u/AmyGEM0icrzmKdntimVMHHRS2okzEAdSI/Vvg++gA&#10;0cFNmcYYZYvHUUDHJZAtw6KifvSKCmcqjLk7Y0hQbEPzLJ5F1rMfApdDCCtAsLgouYWYOIhcnV5H&#10;8ycOosnYk1hMGGNuZhyVR9qooWVYVNSPVeQANR9/bIy5M2kS/W4UVd+D5ij8G/AecAa4EUJYsP3s&#10;t4ygLM/DqLTpMCp3egkZRIzFP2NBYYxZzxhaJ2x73zIsKupHF4mJlfgK+KE15l5ITdxPoT6LXcCT&#10;wGdIWHwTQrgA3GibuIiZiWGUediNPpcXUe/EY/F9P/rcLCSMMXdiFNlM27ChZVhU1I9AKSyW449t&#10;K2vMvTOEDs4/R4flY8ApVA71IXA8hHANuaytNFVgrCtxmkIZnEeRm9NP4msnijp2cPDCGHPvpCZt&#10;0yIsKmpEzwC8RWQpO4+atS0qjNkYBTosP4b6AxZRec/7wAfAV8A3wPkQwhzKCnaRqK9l/0UUEaB/&#10;+xASE1uAvajE6VXUb5J6Jnbh8gVjzMZYQ+eTKyj4aWHRIiwq6kcXHYBm0IO7ilKNxpiNkaZBJwvE&#10;cZTBeAk4h4TF+8Bx4CpwGT17SyGEJUqjhGxFRhQSKSMxjNaKSdS0nuZMpJ6Jl+KvTcY/5/3BGHM/&#10;pOCnzWRahjeN+tFFZRkzaFaFm7WN2RwmUN/AXjR74TngZSQwziCRMQ9ciD+fQZvnfAhhEehWOf9i&#10;XSYiiYhhygm3+5Ed7D70b9yLGrH3x/fdOOtpjHkwhtD6Y0HRQiwq6kcAlpCl7CwWFcZsJkPxNYas&#10;VB9DvUuXUMZiCTgNHEXZixXUj3EBWI0ZjHkUpVuMfz6l/1eA5d6sxt2mzYYQUi9DEgzpz6bG6uF4&#10;vamkaTS+xpFImkQNkwdR4/XTSEDsiP++LbjEyRizuaTghNeVlmFRUU+WkKCYQQcVY8zmk8TAOIrm&#10;P4QO9bMoS5g2zE+RyAjxv7mIMhnnkfCYQOL/EnAphJCyGQHoxjkZ3fjfJlGzvmyp99eGkRCYRKIg&#10;TbEeR0Jhuue1DQmI/cjRaVf88+n/Dd74jTGbS1rLvLa0DIuKerKCDjWzSGAYY/pHygKk6NsuFP1P&#10;G+ZONFk6/fwqejZX0Oa6BQmML5GwmEDP7TmU9ZhFa/EOytKkFdTDkX5vPP5/kkjYRdlIPYcCDEPI&#10;xWkaiYtJyl6R9LLFozGm3wyjtWgYC4tWYVFRM6ID1Apq0p6lbIayw4Ixg6HDzc9bygokdqHMRMoq&#10;DKGD/7PoeR1FouJqfK1ROjFtQ5vxMhIKi/H3xijLmrb0vIr4Zxbi3z0S/9wIZXmUN3VjzCAZRWui&#10;gxgtw6KinqSp2jPosGIHKGPyIR3me5mMr8RafMGtexrS7ydhcidhMI4yJ8YYUzUBrV1dShtu0xIs&#10;KupJspWdRRmLZSwqjKkTveVU9/P7xhiTI2lORbLgtqhoES6ZqSddVD4xg4RFZTaWxhhjjDGRgtL6&#10;PuDyy1ZhUVFfVigdoBYrvhZjjDHGmGSD7dKnFmJRUUOir/0ySi9eRH0VxhhjjDFVktzy1s/WMS3A&#10;oqK+pIFcp1G2wg+uMcYYY6pmvUOeaQn+0uvLGhITZ4ErlE4yxhhjjDFVUSBXu4ADnq3CoqK+BNQI&#10;lQZtLeOH1xhjjDHVsYrcn5IzZbfayzGDxKKiphRF0eXmZu3ktGCMMcYYUwVpOO9ldC6xqGgRFhX1&#10;ZhW4jsqfbmBRYYwxxphqSZb3SzEAalqCRUW96aIH9zwSFn54jTHGGFMVw8j9aQkghOA5FS3CoqLe&#10;BJShuICcoCwqjDHGGFMVI5RN2uDhd63CoqLeBBQNuIxFhTHGGGOqZRHNzlrB7k+tw6Ki/qwgB6hL&#10;qMfCGGOMMaYKbqDzyDywEof1mpZgUVFj4sO6ivopzmIHKGOMMcZUxwLq9UzZCtMiLCrqzxpwDTiD&#10;eisWsbAwxhhjzOApUCn2Ei7Jbh0WFfUnoIjACeB94CIugzLGGGPM4BmNr7WqL8QMHouKmhNLoJaA&#10;c8DH8X250osyxhhjTNsIKDuxRtmobVqERUUzWEUlUCeQqFio9nKMMcYY0zK6lAN5l7CoaB0WFQ0g&#10;ZivmgFPxdb3aKzLGGGNMC7kMnERnEpdAtQyLiuawhBq1TyDnBWOMMcaYQdFBVrIzqAzbmYqWYVHR&#10;HNbQg3wKlUIZY4wxxgyKVRTgXMA9Fa3EoqI5dNGDfBZlLBawnZsxxhhj+k8XlTz1zqiwqGgZFhXN&#10;Yhk1an+NahqdfjTGGGNMvwlIUJxHjdrLnqbdPiwqGkJ8eFeAS8AnwKfADZytMMYYY0x/SXay11EJ&#10;tpu0W4hFRbPoIiFxAjiKH2xjjDHG9J8kKhawrX1rsahoEDFbsYyman+Dshaerm2MMcaYfpLMYmZQ&#10;s7ZpIRYVDaMoijXgKhIVp1FJlDHGGGNMP0jl1ydRT4X7OVuKRUUzmQPOAMeBxWovxRhjjDENJqCz&#10;xllUIWFR0VIsKprJMrKV/RwJi/lKr8YYY4wxTWUZZShOoonadn5qKRYVzWQNWbp9DryPHnY3bBtj&#10;jDFms1lFZ44LwCwuu24tFhUNJEYI5lFfxfuUMyuMMcYYYzaTgITFHLDoLEV7sahoKEVRrKCG7a+Q&#10;qJjDNY7GGGOM2VwCqoZYxo6TrcaiotksIQeok2hmhTHGGGPMZpEG3p0m9lNUezmmSiwqmk3qrfgC&#10;ZSxm8IRtY4wxxmwOAQ3dPU7p/GRaikVFs0kRhM+Bd1GPhRuojDHGGLMZLKPgZaqI8BmjxVhUNJjY&#10;LLWExMTHwBEcRTDGGGPM5jCDshRngAXcu9lqLCqaT6B86I/iYXjGGGOM2RzmUdnTFez81HosKhpO&#10;T7biPBIVV7E7gzHGGGMenDWUoZjDZ4vWY1HRDtZQreNR4EsUUfAwPGOMMcbcL6uob/MKatb2uaLl&#10;DFd9Aab/FEURQghzwDHgT8AuYALYWumFGWOMMaaOJNenkyhgOYtFRetxpqIlFEWxDJwD3gE+Q5kL&#10;1z4aY4wxZqOkKdoXgVPAkvspjEVFu5hHEYVPkVPDChYWxhhjjNkYq8AF4ER8dz+FsahoGWkY3qfI&#10;YvY8HoZnjDHGmI3RRXb1x5HDpEufjEVFywjIpeFL4C1UBuW5FcYYY4y5VwKqdDgFnEbnCgcojUVF&#10;m4j1jisoQ/ERylbM4xIoY4wxxtwbK6hH8xvUU+HgpAEsKlpHFBYLKMLwCXKEmsPCwhhjjDF3JiCn&#10;p8+Br1FJ9aqbtA1YVLSVLhqC9wXwNnAWRR6MMcYYY27HCpqg/RkKSs5YUJiERUUL6clWnADeQIuD&#10;B+IZY4wx5k4sIVFxDJVSL1Z7OSYnPPyupRRFsRZCuAJ8ABxAg/BGgR1AUeW1GWOMMSY7AhIRl5Gg&#10;uF4UhYOR5lssKtrNInJueBt4KL6mgaEqL8oYY4wx2bGGshRfoUnaC9VejskNlz+1mKIousB1yoF4&#10;p3EJlDHGGGO+S+rHPIpdn8wtsKgwq6if4ghq3L6Im7aNMcYYUxKQBf05lKW4jqdom3VYVBhQCvM4&#10;8A7wLnAND7IxxhhjjAioj+IoEhZLdn0y63FPRcspiiKEENaAC6hpez9wENgSX27aNsYYY9pNQFUN&#10;p1CjtkufzHewqDAURdENIcyjlOZbwKPAOPAYMFHhpRljjDGmWnobtI+gagb3X5rv4PInA3w7u2IW&#10;+BLNrvgc1Uw6vWmMMca0k9RLcQT4EJU/zeGzgbkFFhXmW4qiSJMyP0FuUOdwI5YxxhjTVroo4Pg5&#10;GpR7DlhxP4W5FRYVZj3LwBngI7SIXMVpTmOMMaaNdFFm4ijwDRp4Z0Fhbol7Ksx6uqhe8kNgF5qw&#10;/TPUtG2MMcaY9nAdlT59iSoZXL1gbotFhbmJ6Aa1hBwe3gb2AI8AjwOj2A3KGGOMaQNLqHLhfeAY&#10;cMNZCnMnLCrMd4jCYh7NrngTCYoJZDU7VOGlGWOMMWYwzAJfo8qFs8BitZdjcsc9FeZ2pDKoT4B/&#10;Q/0VN/BQPGOMMabpBNRTeTS+ZoqicOmTuSPOVJhbElOcKyGEy8B7aGbFVuB5YBsWpMYYY0wTCaj0&#10;6Rwqezoff27MHbGoMHcj9Vf8CRhDTVrPoQZu3z/G1IMu6odyT5Qx5m6sAReAL9DAOw+7M/eED4Xm&#10;jsRp2zfQ3IoOOpSMox6LqSqvzRhzV9ZQHfQyMAmMYGFhjLk9AVhAJU9p2N18URQufTZ3xaLC3JUo&#10;LK6ivoopYD9yhRpDhxRjTH50gRnk3nIDGS7swuu+Meb2rCEb2S/Rnn8B28iae8Sbi7kniqJY7REW&#10;f0L9FSPAARz5NCY3uuhg8DnqibqBMo1b0LNrjDG3Yg0FI44Ap4E528iae8WiwmyEZdS49Q46mKTh&#10;eBO4cduYnFhGVpB/BP4CrKDypyngCVTCaIwx67kK/A34CGUp3Eth7hmLCnPPxDKoOeAEEhapDOpJ&#10;JCycsTCmelaQp/z/396dPdlV13sff6+9e246ExkYQhgFDiAochSfc3xuPGWVWPVY5Y3/hTeWF97K&#10;n2CVVVrlpVX+AXrx1HNkEFFmAmHMQBIghCSdsaf0sNd6Lj5ruTeoB5J0p3vvfr+qdnWTENho77XW&#10;9/edXiJZxf0k6N8C7AS2ks+un1dJvWZJY/ZfSPnTjFkKXQmDCl2RnsDiMPA8sINun8Xoer43SZTA&#10;NDlp/AvwFhkH2SZNl7eR8dA34SJLSV0dMunxFZKlmCYHFNKXZlChK1YURaeqqnPkgWU7CSxa5EHF&#10;wEJaH83CyreA/0seDk4VRbFcVVWHlC6+AzwKPEJKoMxWSCpJ2dNBcvjwMZn4ZJZCV8SgQlelbtw+&#10;RR5cRkgN9zeAvaQZVNL1UZETxU/JCeMzwAtk6tPlnr9njiyy2k92zdxLyhYlbV4luTYcJhnOt4Gz&#10;OPFJV8GgQtdiAfiQPLA0zVyjwO3r9o6kzadDHgJeA54G/kr6nv5+0lgURVVVVdNrsR+4hwxa2INj&#10;oaXNrDlweB94g1w7FsxS6GoYVOiq1Q8q8ySwgJRTbOl5WbMtra0SuERGxz5fvw6SMZCfWVZV90Nd&#10;qn//BdJbMULKF70XSJvTMjmUOEjGyJ4ngYZ0xbyR6JrUDyoLpAbzBfKQ0iKlUDtIYGHdtrQ2mmkt&#10;z5HP31H+SUDRqPuhTpPdFbeQIQvjuLtC2owqcijxdv36FFgxS6GrZVCha1YHFvPkgaZFTk87pCF0&#10;D2YspLWwSD5zz9WvQ8ClfxVQ9GjKFl8nfRW3YVAhbUbNffuvOEJWq8CgQquiPgG9RJq9KpKxmCIL&#10;t6ZwOZ60mjrARyQ78TQ5ZTxXFMUXNlfWhwAz5GHifeB+sm9mGLOK0maxTIY5vEoOGD4lA1ekq2ZQ&#10;oVXTU7N9hPRX7Ky/foVuj4UPLdLVK0mm4RTZlP00aa6cLoriSmbKr5A59O+Qz+ceUg5lVlEafBXp&#10;nXiLXEeOkbJJsxS6JgYVWlV18/YsOQFtRs0ukhGW2/FnTroW88AHZLHdM2Sk8xmufPxj0+D9DslS&#10;7CKfz0kM/KVBVpF78hHgJTKG+iwuutMq8AFPq64uhbpIHliacbNt4KskYyHpylQkQP8QeBb4bzIa&#10;9hSwfKUnjHXwvwicIKUPe4CbyahZAwtpcK2QUqe36tcJ4LJZCq0GgwqtiXo53jngXRJQTJAdFveT&#10;iTOSvpwOcJFuD8WfSEDxaVEUV10DXZcrzpHSh5dJw/ZWUrLovUEaPB3gAunBepU0Z18imUvpmnnj&#10;0JrpCSzeIT9rJdnw+wB5eLF+W/qfNQHFO8CLZA/F68BpVqFcoQ4szpNyxVdI0L8b7w3SIJoj5ZMv&#10;kYOJk9dyMCF9njcOrak6sJgmpyIz5JRkHvgasA0nzkj/SkV3D8UzpOzpHVL/vLRa5QpFUSxXVXWm&#10;/mcfBPaSrKL3B2lwLNKd9vQSCS5m1/UdaeB409D10Jy2vktOVxfr18OklnsUAwup1wqZ8nSUTHh6&#10;hpQsnGVtllM1/64/kyziMOmxcBS01P9KMtDhANlJ8S5w0T4KrTaDCq25+sK1Uo+bPUT3gek88Bhw&#10;B+m5kNR9AHiHjHt8hjqguMKxsVeiQwKWV4EbSQnULjLBTVL/Ksmh3vukJ+tNMk7aaU9adQYVum56&#10;lm4dJr0VcyRDMUZKLnyA0WZXAudIvfNTdDfdXvgyi+2uVj0N6jKZLvUKcBMJKu4kmURJ/aci99pj&#10;ZBjDq2Tgg9OetCYMKnRdfW7iTAcYJ8FERcotxrEUSptPRTJ4zUKqp0kPxUFgpiiKNZ/OUgcWc+RE&#10;c4rsrdhKAgw/k1L/WSZjp18nQcVhYLYois66visNLIMKXXc9M/I/Jg9PF8np7H9x/ax4AAAWuklE&#10;QVSSUqhJrOXW5lGSHRQnSc3zn4HnSKngdQkoGvWOmfOk5no3mQY1ScZA+5mU+kdJBqM0k+OaIQ8G&#10;FFozBhVaFz3lFifICe0sCS4eJ9u3d+PpqAZf87P/MSlNeK7++iE5UVyP+fHN6eYrwC3kIeQBMq1t&#10;CD+XUj+YJROeXiTllJ8Ai5Y9aS0ZVGjd9GQsTpJpUHMkYzEDPEpquh05q0HVlDu9S0oTXgTeIDf/&#10;hfUqUag/lwvAcdIk3mQovkoCCz+P0sa2SA7sXiPXlmPkkMKAQmvKoELrqr7ILdW7LBbJ6co8aS57&#10;hPRZTOCiPA2OivyMnyY1zs+Shuz3WeUdFFerp/fpPdLzdAMJKEbJ59HAQtqYOmS60wEy7eld4Pw6&#10;ZT21yRhUaEOol+RdJHXkS8AlcmF8jEyg2YJZC/W/igTPR8gJ4ivkNPEwKf8r1zugaNT9FRfIZ3IX&#10;2SkzCdyGE6GkjahD7p3NOOr95PBizSbHSb0MKrRh9JyOHiWlUNPkgvjvpKa7WZRnw6j61TIJKP5M&#10;RsYeIP0L8xtxIksdWJwls+1vIFOhtpCeJ0kbyxz5rD5Ngorj2Eeh68igQhtKHVjMk3rQeTK94jRZ&#10;BvYIsI+MubQcSv1kmfwsHwP+QnoV9pOAYt3Lnb5AU5/9Khkzu4vslpnCzKG0UTT7KJ4nAcUR1m/Y&#10;gzYpgwptOD19FmfI5u0LJKiYBr4B3EMebCzB0EZXktKDT8n+ib/Vr/fIz/TyBg8oejOIHwIvkb0V&#10;28i42eH1fG+SgFxjTpCSyr/RXZhpQKHryqBCG1bPBu6jdHssTgHfIpNo9pITU8uhtBF1SDnCSbJ8&#10;6llyw/+QDCRY2egBRaP+LM6Sh5XnSfnTDmAnaeQ2YyFdfxW5zpwm15hngLeBs0VR2Eeh686gQhta&#10;z9jZ0yRrcY6c+p4iTdz3kBpvf5a1UVQkQ9E8hD9FSp7eIT+7ixuxf+JLWCGfvzfoLsP7NtllMYaB&#10;hXQ9VWSoyQVSSvkMyVScqn9duu58ENOGV5/mLteTaBbJHouzJNBoluU1Tdw+2Gg9rZCfyw/J1KTX&#10;yf6JQ6QcYXkd39s16fkcfkrKoCry3/s4cDswvo5vT9pslskhxaskoPgrWaJ5uV8yoBo8BhXqG3V9&#10;6FxVVR+RspLzJLiYplsO1Yyela6nptTpNDk1fJn0UBwhy+zmBqi++TLwEQkqChJMTAC34gAF6Xoo&#10;yf3vLeBPJBN6lEyRM6DQujGoUN8pimK5XpY3Ty6sp0iT2iPAfaTeexx7LbT2mprmCySAeIP0HOwn&#10;p4az9EEz9pWo/1sWqqpqNvZuJ+VQw8CNuE9GWksV6TF8n1xrXgSOFkUxs67vSsKgQn2qnp8/R0bo&#10;XSTzuA+SJu7ehXktfMDR6qtI+cEC+fk7SE4LX6i/P01O9DfMMrs10GQs/kzKoC6TnTI3Y7ZQWgvN&#10;8sz3SK/Wc8AHJEsqrTuDCvWtupzkcj16dpaUQp0k9eyPAQ+TkqhWz0taDQuk3OA90i/xHmnEPkaC&#10;jIHKTvwzPTtljtJtTh8iWYsd6/nepAG1Qg4tniHT5N4HZgaotFJ9zqBCfa8enTdTT4m6RJrXjpMH&#10;vIdJOdQeUqbhz7yuxRIpuTtCshKvkKDiJAkm5jfTDb7OGM6SwKIFTJKA4iGypNJAXrp2HXKQcZJk&#10;J54D3gXOOzpWG4kPWBoYRVEsVVV1lmQtTpMHvzfJdKim32In9lvoyjQL7BZIwPo2mX70Ejk1PEvG&#10;xA50ZuJf6dlhcZTs4Zgi/5s9QJbkDWEJonS1mh6Ko2TS01OkQfucAYU2GoMKDZT6Aecyad6+SEqh&#10;DpLMxWPkBLXpt/BhR19khW6Q+hEJUl8hN/WBbMS+GvU+mVlSjlGQjM4S8DWSuXAqlHTlKrqlls8C&#10;T5NhEKfJtUnaUAwqNHDqB7yVupH7MtlrcYY0tL1DgouvkxGYY80fwwBDXU2PwDmSmXiR3MwPkxKE&#10;86RhcpAbsa9IXQp1ifSXtMhnazvJDE7i50u6EiW5xhwjOyieIlPlzgBLXne0ERlUaGA1wQVwqc5e&#10;nCOnzcdIBuNBEljsIWUao+vzTrXBzJLdEsdIluvN+nWMlCEsbqa+iStRFMVKVVUXScZihAQXl0kJ&#10;4nYsO5S+jGZM9UHSu/UMCShOF0XhtmxtWAYV2hR6+i2arMXHwAHgHvLAcy8ZhTlJxmFaGrV5lGQ8&#10;7CIJKJra5VfJw/HHJCB1U+2XUGcszpNA7DL533SOLKjcheNmpS9ykWRI/0R2UbwDTBdFsbyu70r6&#10;AgYV2jTquu8lsoF7lpw8v0ECi6+TzMVtpAZ8J9kSbC34YLtMbuBn6U4Ne4ssdTtCgolFoGNA8eXV&#10;GYvz5GFongQV88A3yDS2JoshKZpFmvPkMOOp+vUucKEois46vjfpSzGo0KZSPxh26vn6zQjaU6RW&#10;/iXgLpK1eLD+emP9R9v4EDQomn6JJZKV2E8CiSMkK3GKBBlzwIrBxNWpMxYzpJepWdo1RwL4fWSf&#10;hdlAKZZJA/YhslDyKRJcXDSgUL8wqNCm1NPM3aF7Wn2CXMTfJqdDD5EgYzdZotdMjFL/Kkmm6k1y&#10;in6A1C2fJDXM8yTYMJhYBT17LI7QLS+bA75LGrj9PEnp/ZsmJZfPkcEQ75NrkgGF+oYXdG1qTeaC&#10;jO1bqKrqAjktOk4eOm8H7iZL9O4lZVGjuOui33TKsry4vLx8fGVl5dXh4eFnhoaGDrRarY/xJHBN&#10;1U3ts1VVHSMBW4dulqJ3Apu0GTVT5t4kI2P/QrJ7M1h2qT5jUCH1qGvBL5DT1JNkPObNJHPxDdJ/&#10;sQu4iSz5GiX14W0cS7thVFXF0tJSZ2VlZbGqqosjIyMny7I8eP78+RcPHDjw/IULFw5t27Zt5nvf&#10;+54jYa+ToiguV1V1gpRCtUhW6NskcLd/SZtNUxJ4npRfNk3Zh4EZJ8ypHxlUSJ9TN3QvkxrXBVIa&#10;9QkJLPaRZu47gFvqv76VBBgj9cvJUeujAsqyLFeWl5cXT5w4cfG999774IMPPnhp9+7dz957770H&#10;t2/fPj03Nzf/1ltvLT/55JPetK+/JfJZep70M50D/jfJAm7Fe5I2h4qU3X4EvEy35OkoMGtAoX7l&#10;BVz6J3pOr3uX6F0g+y22kjKo3eSU9U6SzdhLAo7dpDxK19fiysrKh5cuXXr50qVLr50+ffrYxx9/&#10;fPoXv/jF6TNnzpwi5QTerNdR/blarKrqFKkjnyOBxX+Q7ds348hZDbYVMgjiIBkO8gIpfToBLBhQ&#10;qJ8ZVEhfoGeJ3gowX4/K/ITstHiPboBxJ9l58RW65VE7SIBRYg/GqquqaqUsy0+qqnqj1Wq93+l0&#10;jpw5c+bd3/3ud+8/+eST0+T/M20w9d6YMyRzMUuyFgvAo3T3xZjt0yApyc/4GZL1fo4EFIeAM0VR&#10;LK7je5NWhRdt6SpVVdUideBDpNl0J93G7n3k4egesrF7nGwUburG26RUSlfnMnCuLMujS0tLL12+&#10;fPmPs7Ozr//+978//7Of/cweiT5RVVWbBBC3Af9OMhZfJwG609Y0KEq6izUPAK/QDSguYUO2BoRB&#10;hXSNqqoqSBaiRRq3byABxE66JVF3kCzGWP33TdENNobpNnrrHzUTupqt1wukDO0vwH+vrKy8vbCw&#10;MD09Pb141113WTrQZ+rgfJQE4Q8C36pf99PdwG2WT/2qImV+H5DpTs+TseWfkP4Js6kaGD7ESKuo&#10;J8AYIg9KE/VrCthGdxztTpLF+CrwACmXarYM+7mMZkndZXID3k+aGj+o//pT6iV1joTtb/XnZpiU&#10;C95NyqAeBx4hWT+nQ6kfNdev48D/q19vkhKoJa9bGjSmlqVV1LP3okMaUmfoBgpNNmOYlHzcSCZH&#10;3Vp/v63+/iEScGy73u9/g2jmth8n5QHHSNnA4fo1XRTF/Lq9O626+nPT9Fk0yyinyc6Yb5A+pR1Y&#10;Mqj+cpJkJV4GniW7j84URbG0ru9KWiOeiEobQFVVQ6SG/A5SW/7Vqqr2VFW1DdhVFMWeoihuZPAm&#10;4zSjFWdI1mG6/vohaYJ/iwQUZ4HL1h0PvjprMUaGH9wHPEayFv9GMnoTWA6ljatDyp3OkDGxz5Ae&#10;iqNk/4TZCQ0sgwppg6gfptpAe3l5eWh+fn68qqpbR0dHvzY8PPwf7Xb763VgMQ6MV1U1DgwVRdEP&#10;D1gl6YlYIkHEEumPmCeBxAekLOANkqE4V/99nfrPVgYUm0f9WRgi45tvJ83bj9dfb6fbxO09TBtB&#10;U6pZktHj75NG7OfJde1Tcihiz5cGmhdkaYN64oknit/85jcj27ZtmxgZGZkaGhraVhTFrrIs7+p0&#10;Ot8CHiuK4rZ2uz1RBxbNRu8myCg+9/V6qHq+Nq9lkon4hKT/D5AyppP1ry+SAGK+fi3avCj4+3So&#10;CTLU4AHgmyST92/1r1kOpfXWe407SwKK54G/kuvceXJN81BEA8+gQuojnU5ntNPpbCvLci9wS6vV&#10;2tput8dardYkaf7eR0qobiYTqCZIydTVlk01gUHzfVlV1d9/rSgKyHWkOalr9g6cJun+4ySYmCbZ&#10;h9PAqfr7GU/u9EXqrMUo+Xlumri/RbeJ+wa8l2n9LJJMxAFSrvkW6aM4TgINx8Vq0/BCLA2AqqrG&#10;q6raCdxWFMUddIOKSVIm0oytHSElJdtJzfrW+vcrMi/9HN0AYIGUH1H/flUHFE0gUBV1VEE3+Fgk&#10;QcUZukHFp8AlAwhdizprcQMZ0fwwyVg8QgKN3STw8J6m66UkAwWOk8l0TanTR6QEyh4wbTpegKUB&#10;UZZlART1g37zoudrRXfR2B1kJ8A+0hRbkozCofp1lAQZKz1/nsQUf/9nfT5T0au3/Ml+CK2KnqzF&#10;LhJMPEQauR8DbiFBx6ANM9DGUZJr4iLJQrxLypxeJKWdTe+E1zttSgYV0ibSsw9gmDycDdO9DqyQ&#10;8qUlMkPdzII2nJ4m7htIcHEfKYf6dv39jSQj1xtYS9eq2Yp9imQnjpAMxetk0MQlct00oNCm5QVX&#10;ktR36k3cI2Sfyz6ySPJxkr24lSycvAH3MenaNLuHZkkW92Uype4IKXU6jaNiJcCgQpLUx+pei2ZL&#10;/f0kqLiPlEfdQ7ffQroay8AJsjfnJTIq9iCZ9LQALJvVlcKgQpLU13p2vDQlUXeS4OLfSe/QXpK5&#10;MGuhL6NDxlvPkD6J14G/kQzFMdKI7VQn6XMMKiRJA6EuiWqCi1tIxuJh4Gv1110kq9HsdZF6NY3Y&#10;F0lm4nUyKvZdepZympmQ/jkvqpKkgdLTbzFJxibfTHou/ovsubgFS6L0WSukb+ITkpF4of56nCyw&#10;mwdWzE5I/5pBhSRpoFVVNUx6Lh4izdzfBf4Xjp9VXCaN12/QXWB3GDgJzGEwIX0p1pdK2jDq2ni8&#10;gWs1FUWxDJysquoUcKgsy0/LslwqiuL+Vqu1qyiKsfV+j7quOiSQuEimN50EXiF9EwfJAlAzE9IV&#10;MlMhaUOoA4oWLszTGqqqqnXo0KHtY2NjD+/YseP/jI6OPt5qte4EtrZarRHyM6jB04yGvUwmN30I&#10;vA28SvZMfAScISVQNmFLV8GgQtKGUVVV4c1ca+23v/1t69vf/vb4nj17dp47d+4rw8PD39myZct3&#10;t27den+r1dpKmr29Pw6Gpvl6gQQTR0lGYj/plzhFpjw5Hla6Rl40JUmb1qOPPjrxy1/+cu9NN930&#10;ULvd/tbIyMh/Tk5O3j8xMbF1aGiovd7vT9dkiUxxegN4n2QjPiVZijPU/RKYmZBWhUGFJEkw+vOf&#10;//yuJ5544vGbb7750YmJifvb7fZXxsfHbxofHx8dGrIFsU+UJFg4T3ZKPA08R8bCnqn7ayStAU9h&#10;JEmCzve///1z7Xb77T/84Q/7Dx8+fGxmZmZhYmJieWxsbH5oaGiuqqpF0u/T9P94MLcxVCSYWCTB&#10;xEESSPwB+BPJVpwvimJl3d6htAl4QZQk6bPaP/nJT8a++c1v3vDggw9OtFqtHcPDw3dOTU09vH37&#10;9kfGxsbuabfbe6qqmiCHc+060GheWhtNiVJJN5BogokZMsnpCJnk9DIpeToHLNkrIa09L36SJP3P&#10;2r/61a+2fOc737lx7969O4eHh3cuLi7etLS0dHu73f7KxMTEfWNjY7e22+2tZOmeVl9JeiRmyMjX&#10;U2QU7On6+9OkT6L5/hwwWxRFZ13erbQJGVRIknSFpqampn7961/vuf/++/ft27fvjsnJyVvKsrxp&#10;YWFh79LS0r52u33L2NjY9vHx8ZGhoSGSyNBVWgYuAB8Dh0h50wfACRJAnCc7J+bsmZDWj1c5SZKu&#10;0muvvVa0Wq3ij3/84/D09PT2bdu23XPnnXd+7Y477nhg7969e3fv3r1lbGxsBBiqqmq4LMtxYKrd&#10;bt/QarXGi6Jwq3eUZI/EMslILJKdEvMk63AceIfsljhMMhKz9d9f4m4bad05zkKSpKv06KOPVkA1&#10;MjKy9KMf/ejM+Pj4+bIs36iqarjT6QzNzMwMTU9PD09PT08uLCzsHB0dvWPbtm1f3bVr1wOTk5P7&#10;hoeHd5CSqWbpXtME3qLu1+j5vp97Nio+2wfRvJpAYh64RHZJNFuuT5JsxCf199Ok/Gmp/nMGEtIG&#10;0q8XJ0mS+snQD3/4w5Ef//jHE/fdd9/Wffv2TW3ZsmViaGhotCzL4bIsR1qt1mir1RpvtVpbgJ3A&#10;rcC++utNwBSfDUD6Qe9kpjlSxnSW9D+crl9n69dFElhcIlmIebKUbqH+8ys2XEsbl0GFJEnrr7V/&#10;//6he++9d2R8fHyCBBA3kuBiB7ANGCdlVC2gKMuyqKqqVZZlM962KIqiaLVaFEXRvJrMRxsYrf8Z&#10;k/XXYYCyLKuyLKmqqirLsvefUbXb7SaT0DQ8T9TvZ0/93qZI1UNJt1zpEgkQLtSvi6Tv4QIpZTpf&#10;f21+b5YEHIskC2HwIPUhgwpJkvpPb5lUqyiK1k9/+tPioYceKu6++2727dvH1q1bi8nJyWJoaKhF&#10;HvzHSRAwBdxAPalqaWmJxcXFanl5uVpZWSlarVZreHiYkZGRamxsbLlufl6u/503ALcAdwN3kgzK&#10;KAkoLvKPWYhpulmIWbpZhw4JRD77H2U5k9S37KmQJKn/VEDnBz/4QTk1NcXu3bu5/fbb2b59O+Pj&#10;4wwNDdFkLGoFyRAUn3v9g38yqar3Qb8gQcRWkknZTrIgcyRDMUMChyVghbr3ge5uiQp7IaSBZKZC&#10;kiR9aVVVNVmSofpV0G267gAdgwZJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ&#10;kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJktbC&#10;/wcO9A7eMaXQEQAAAABJRU5ErkJggg==&#10;"

     

       45
       +
              id="image1"

     

       46
       +
              x="-233.6257"

     

       47
       +
              y="10.383364"

     

       48
       +
              style="display:none" />

     

       49
       +
           <path

     

       50
       +
              fill="currentColor"

     

       51
       +
              style="stroke-width:0.111183"

     

       52
       +
              d="m 16.348974,24.09935 -0.06485,-0.03766 -0.202005,-0.0106 -0.202008,-0.01048 -0.275736,-0.02601 -0.275734,-0.02602 v -0.02649 -0.02648 l -0.204577,-0.04019 -0.204578,-0.04019 -0.167616,-0.08035 -0.167617,-0.08035 -0.0014,-0.04137 -0.0014,-0.04137 -0.266473,-0.143735 -0.266475,-0.143735 -0.276098,-0.20335 -0.2761,-0.203347 -0.262064,-0.251949 -0.262064,-0.25195 -0.22095,-0.284628 -0.220948,-0.284629 -0.170253,-0.284631 -0.170252,-0.284628 -0.01341,-0.0144 -0.0134,-0.0144 -0.141982,0.161297 -0.14198,0.1613 -0.22313,0.21426 -0.223132,0.214264 -0.186025,0.146053 -0.186023,0.14605 -0.252501,0.163342 -0.252502,0.163342 -0.249014,0.115348 -0.249013,0.115336 0.0053,0.03241 0.0053,0.03241 -0.1716725,0.04599 -0.171669,0.046 -0.3379966,0.101058 -0.3379972,0.101058 -0.1778925,0.04506 -0.1778935,0.04508 -0.3913655,0.02601 -0.3913643,0.02603 -0.3557868,-0.03514 -0.3557863,-0.03514 -0.037426,-0.03029 -0.037427,-0.03029 -0.076924,0.02011 -0.076924,0.02011 -0.050508,-0.05051 -0.050405,-0.05056 L 6.6604532,23.110188 6.451745,23.063961 6.1546135,22.960559 5.8574835,22.857156 5.5319879,22.694039 5.2064938,22.530922 4.8793922,22.302961 4.5522905,22.075005 4.247598,21.786585 3.9429055,21.49817 3.7185335,21.208777 3.4941628,20.919385 3.3669822,20.705914 3.239803,20.492443 3.1335213,20.278969 3.0272397,20.065499 2.9015252,19.7275 2.7758105,19.389504 2.6925225,18.998139 2.6092345,18.606774 2.6096814,17.91299 2.6101284,17.219208 2.6744634,16.90029 2.7387984,16.581374 2.8474286,16.242088 2.9560588,15.9028 3.1137374,15.583492 3.2714148,15.264182 3.3415068,15.150766 3.4115988,15.03735 3.3127798,14.96945 3.2139618,14.90157 3.0360685,14.800239 2.8581753,14.698908 2.5913347,14.503228 2.3244955,14.307547 2.0621238,14.055599 1.7997507,13.803651 1.6111953,13.56878 1.4226411,13.333906 1.2632237,13.087474 1.1038089,12.841042 0.97442,12.575195 0.8450307,12.30935 0.724603,11.971351 0.6041766,11.633356 0.52150365,11.241991 0.4388285,10.850626 0.44091592,10.156842 0.44300333,9.4630594 0.54235911,9.0369608 0.6417149,8.6108622 0.7741173,8.2694368 0.9065196,7.9280115 1.0736303,7.6214262 1.2407515,7.3148397 1.45931,7.0191718 1.6778685,6.7235039 1.9300326,6.4611321 2.1821966,6.1987592 2.4134579,6.0137228 2.6447193,5.8286865 2.8759792,5.6776409 3.1072406,5.526594 3.4282004,5.3713977 3.7491603,5.2162016 3.9263009,5.1508695 4.1034416,5.0855373 4.2813348,4.7481598 4.4592292,4.4107823 4.6718,4.108422 4.8843733,3.8060618 5.198353,3.4805372 5.5123313,3.155014 5.7685095,2.9596425 6.0246877,2.7642722 6.329187,2.5851365 6.6336863,2.406002 6.9497657,2.2751596 7.2658453,2.1443184 7.4756394,2.0772947 7.6854348,2.01027 8.0825241,1.931086 8.4796139,1.851902 l 0.5870477,0.00291 0.5870469,0.00291 0.4447315,0.092455 0.444734,0.092455 0.302419,0.1105495 0.302417,0.1105495 0.329929,0.1646046 0.32993,0.1646033 0.239329,-0.2316919 0.239329,-0.2316919 0.160103,-0.1256767 0.160105,-0.1256767 0.160102,-0.1021909 0.160105,-0.1021899 0.142315,-0.082328 0.142314,-0.082328 0.231262,-0.1090091 0.231259,-0.1090091 0.26684,-0.098743 0.266839,-0.098743 0.320208,-0.073514 0.320209,-0.073527 0.355787,-0.041833 0.355785,-0.041834 0.426942,0.023827 0.426945,0.023828 0.355785,0.071179 0.355788,0.0711791 0.284627,0.09267 0.284629,0.09267 0.28514,0.1310267 0.28514,0.1310255 0.238179,0.1446969 0.238174,0.1446979 0.259413,0.1955332 0.259413,0.1955319 0.290757,0.296774 0.290758,0.2967753 0.151736,0.1941581 0.151734,0.1941594 0.135326,0.2149951 0.135327,0.2149952 0.154755,0.3202073 0.154758,0.3202085 0.09409,0.2677358 0.09409,0.267737 0.06948,0.3319087 0.06948,0.3319099 0.01111,0.00808 0.01111,0.00808 0.444734,0.2173653 0.444734,0.2173665 0.309499,0.2161102 0.309497,0.2161101 0.309694,0.2930023 0.309694,0.2930037 0.18752,0.2348726 0.187524,0.2348727 0.166516,0.2574092 0.166519,0.2574108 0.15273,0.3260252 0.152734,0.3260262 0.08972,0.2668403 0.08971,0.2668391 0.08295,0.3913655 0.08295,0.3913652 -6.21e-4,0.6582049 -6.21e-4,0.658204 -0.06362,0.315725 -0.06362,0.315725 -0.09046,0.289112 -0.09046,0.289112 -0.122759,0.281358 -0.12276,0.281356 -0.146626,0.252323 -0.146629,0.252322 -0.190443,0.258668 -0.190448,0.258671 -0.254911,0.268356 -0.254911,0.268355 -0.286872,0.223127 -0.286874,0.223127 -0.320203,0.187693 -0.320209,0.187693 -0.04347,0.03519 -0.04347,0.03521 0.0564,0.12989 0.0564,0.129892 0.08728,0.213472 0.08728,0.213471 0.189755,0.729363 0.189753,0.729362 0.0652,0.302417 0.0652,0.302419 -0.0018,0.675994 -0.0018,0.675995 -0.0801,0.373573 -0.08009,0.373577 -0.09,0.266839 -0.09,0.26684 -0.190389,0.391364 -0.19039,0.391366 -0.223169,0.320207 -0.223167,0.320209 -0.303585,0.315294 -0.303584,0.315291 -0.284631,0.220665 -0.284629,0.220663 -0.220128,0.132359 -0.220127,0.132358 -0.242395,0.106698 -0.242394,0.106699 -0.08895,0.04734 -0.08895,0.04733 -0.249052,0.07247 -0.24905,0.07247 -0.322042,0.0574 -0.322044,0.0574 -0.282794,-0.003 -0.282795,-0.003 -0.07115,-0.0031 -0.07115,-0.0031 -0.177894,-0.0033 -0.177893,-0.0033 -0.124528,0.02555 -0.124528,0.02555 z m -4.470079,-5.349839 0.214838,-0.01739 0.206601,-0.06782 0.206602,-0.06782 0.244389,-0.117874 0.244393,-0.11786 0.274473,-0.206822 0.27447,-0.20682 0.229308,-0.257201 0.229306,-0.2572 0.219161,-0.28463 0.219159,-0.284629 0.188541,-0.284628 0.188543,-0.28463 0.214594,-0.373574 0.214593,-0.373577 0.133861,-0.312006 0.133865,-0.312007 0.02861,-0.01769 0.02861,-0.01769 0.197275,0.26212 0.197278,0.262119 0.163613,0.150814 0.163614,0.150814 0.201914,0.09276 0.201914,0.09276 0.302417,0.01421 0.302418,0.01421 0.213472,-0.08025 0.213471,-0.08025 0.200606,-0.204641 0.200606,-0.204642 0.09242,-0.278887 0.09241,-0.278888 0.05765,-0.302418 0.05764,-0.302416 L 18.41327,13.768114 18.39502,13.34117 18.31849,12.915185 18.24196,12.4892 18.15595,12.168033 18.06994,11.846867 17.928869,11.444534 17.787801,11.042201 17.621278,10.73296 17.454757,10.423723 17.337388,10.263619 17.220021,10.103516 17.095645,9.9837986 16.971268,9.8640816 16.990048,9.6813736 17.008828,9.4986654 16.947568,9.249616 16.886308,9.0005655 16.752419,8.7159355 16.618521,8.4313217 16.435707,8.2294676 16.252892,8.0276114 16.079629,7.9004245 15.906366,7.773238 l -0.20429,0.1230127 -0.204289,0.1230121 -0.26702,0.059413 -0.267022,0.059413 -0.205761,-0.021508 -0.205766,-0.021508 -0.23495,-0.08844 -0.234953,-0.08844 -0.118429,-0.090334 -0.118428,-0.090333 h -0.03944 -0.03944 L 13.711268,7.8540732 13.655958,7.9706205 13.497227,8.1520709 13.338499,8.3335203 13.168394,8.4419112 12.998289,8.550301 12.777045,8.624223 12.5558,8.698155 H 12.275611 11.995429 L 11.799973,8.6309015 11.604513,8.5636472 11.491311,8.5051061 11.37811,8.446565 11.138172,8.2254579 10.898231,8.0043497 l -0.09565,-0.084618 -0.09565,-0.084613 -0.218822,0.198024 -0.218822,0.1980231 -0.165392,0.078387 -0.1653925,0.078387 -0.177894,0.047948 -0.177892,0.047948 L 9.3635263,8.4842631 9.144328,8.4846889 8.9195029,8.4147138 8.6946778,8.3447386 8.5931214,8.4414036 8.491565,8.5380686 8.3707618,8.7019598 8.2499597,8.8658478 8.0802403,8.9290726 7.9105231,8.9922974 7.7952769,9.0780061 7.6800299,9.1637148 7.5706169,9.2778257 7.4612038,9.3919481 7.1059768,9.9205267 6.7507497,10.449105 l -0.2159851,0.449834 -0.2159839,0.449834 -0.2216572,0.462522 -0.2216559,0.462523 -0.1459343,0.337996 -0.1459342,0.337998 -0.055483,0.220042 -0.055483,0.220041 -0.015885,0.206903 -0.015872,0.206901 0.034307,0.242939 0.034307,0.24294 0.096281,0.196632 0.096281,0.196634 0.143607,0.125222 0.1436071,0.125222 0.1873143,0.08737 0.1873141,0.08737 0.2752084,0.002 0.2752084,0.002 0.2312297,-0.09773 0.231231,-0.09772 0.1067615,-0.07603 0.1067614,-0.07603 0.3679062,-0.29377 0.3679065,-0.293771 0.026804,0.01656 0.026804,0.01656 0.023626,0.466819 0.023626,0.466815 0.088326,0.513195 0.088326,0.513193 0.08897,0.364413 0.08897,0.364411 0.1315362,0.302418 0.1315352,0.302418 0.1051964,0.160105 0.1051954,0.160103 0.1104741,0.11877 0.1104731,0.118769 0.2846284,0.205644 0.2846305,0.205642 0.144448,0.07312 0.144448,0.07312 0.214787,0.05566 0.214787,0.05566 0.245601,0.03075 0.245602,0.03075 0.204577,-0.0125 0.204578,-0.0125 z m 0.686342,-3.497495 -0.11281,-0.06077 -0.106155,-0.134033 -0.106155,-0.134031 -0.04406,-0.18371 -0.04406,-0.183707 0.02417,-0.553937 0.02417,-0.553936 0.03513,-0.426945 0.03513,-0.426942 0.07225,-0.373576 0.07225,-0.373575 0.05417,-0.211338 0.05417,-0.211339 0.0674,-0.132112 0.0674,-0.132112 0.132437,-0.10916 0.132437,-0.109161 0.187436,-0.04195 0.187438,-0.04195 0.170366,0.06469 0.170364,0.06469 0.114312,0.124073 0.114313,0.124086 0.04139,0.18495 0.04139,0.184951 -0.111218,0.459845 -0.111219,0.459844 -0.03383,0.26584 -0.03382,0.265841 -0.03986,0.818307 -0.03986,0.818309 -0.0378,0.15162 -0.03779,0.151621 -0.11089,0.110562 -0.110891,0.110561 -0.114489,0.04913 -0.114489,0.04913 -0.187932,-0.0016 -0.187929,-0.0016 z m -2.8087655,-0.358124 -0.146445,-0.06848 -0.088025,-0.119502 -0.088024,-0.119502 -0.038581,-0.106736 -0.038581,-0.106736 -0.02237,-0.134956 -0.02239,-0.134957 -0.031955,-0.46988 -0.031955,-0.469881 0.036203,-0.444733 0.036203,-0.444731 0.048862,-0.215257 0.048862,-0.215255 0.076082,-0.203349 0.076081,-0.203348 0.0936,-0.111244 0.0936,-0.111245 0.143787,-0.06531 0.1437865,-0.06532 h 0.142315 0.142314 l 0.142314,0.06588 0.142316,0.06588 0.093,0.102325 0.093,0.102325 0.04042,0.120942 0.04042,0.120942 v 0.152479 0.152477 l -0.03347,0.08804 -0.03347,0.08805 -0.05693,0.275653 -0.05693,0.275651 2.11e-4,0.430246 2.12e-4,0.430243 0.04294,0.392646 0.04295,0.392647 -0.09189,0.200702 -0.09189,0.200702 -0.148688,0.0984 -0.148687,0.0984 -0.20136,0.01212 -0.2013595,0.01212 z"

     

       53
       +
              id="path4" />

     

       54
       +
         </g>

     

       55
       +
       </svg>

     

       56
       +
       {{ end }}

+57

appview/pages/templates/fragments/dolly/silhouette.html

···

       1
       +
       {{ define "fragments/dolly/silhouette" }}

     

       2
       +
       <svg

     

       3
       +
          version="1.1"

     

       4
       +
          id="svg1"

     

       5
       +
          width="32"

     

       6
       +
          height="32"

     

       7
       +
          viewBox="0 0 25 25"

     

       8
       +
          sodipodi:docname="tangled_dolly_silhouette.png"

     

       9
       +
          xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"

     

       10
       +
          xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

     

       11
       +
          xmlns="http://www.w3.org/2000/svg"

     

       12
       +
          xmlns:svg="http://www.w3.org/2000/svg">

     

       13
       +
         <style>

     

       14
       +
           .dolly {

     

       15
       +
             color: #000000;

     

       16
       +
           }

     

       17
       +
       

     

       18
       +
           @media (prefers-color-scheme: dark) {

     

       19
       +
             .dolly {

     

       20
       +
               color: #ffffff;

     

       21
       +
             }

     

       22
       +
           }

     

       23
       +
         </style>

     

       24
       +
         <title>Dolly</title>

     

       25
       +
         <defs

     

       26
       +
            id="defs1" />

     

       27
       +
         <sodipodi:namedview

     

       28
       +
            id="namedview1"

     

       29
       +
            pagecolor="#ffffff"

     

       30
       +
            bordercolor="#000000"

     

       31
       +
            borderopacity="0.25"

     

       32
       +
            inkscape:showpageshadow="2"

     

       33
       +
            inkscape:pageopacity="0.0"

     

       34
       +
            inkscape:pagecheckerboard="true"

     

       35
       +
            inkscape:deskcolor="#d1d1d1">

     

       36
       +
           <inkscape:page

     

       37
       +
              x="0"

     

       38
       +
              y="0"

     

       39
       +
              width="25"

     

       40
       +
              height="25"

     

       41
       +
              id="page2"

     

       42
       +
              margin="0"

     

       43
       +
              bleed="0" />

     

       44
       +
         </sodipodi:namedview>

     

       45
       +
         <g

     

       46
       +
            inkscape:groupmode="layer"

     

       47
       +
            inkscape:label="Image"

     

       48
       +
            id="g1">

     

       49
       +
           <path

     

       50
       +
              class="dolly"

     

       51
       +
              fill="currentColor"

     

       52
       +
              style="stroke-width:1.12248"

     

       53
       +
              d="m 16.208435,23.914069 c -0.06147,-0.02273 -0.147027,-0.03034 -0.190158,-0.01691 -0.197279,0.06145 -1.31068,-0.230493 -1.388819,-0.364153 -0.01956,-0.03344 -0.163274,-0.134049 -0.319377,-0.223561 -0.550395,-0.315603 -1.010951,-0.696643 -1.428383,-1.181771 -0.264598,-0.307509 -0.597257,-0.785384 -0.597257,-0.857979 0,-0.0216 -0.02841,-0.06243 -0.06313,-0.0907 -0.04977,-0.04053 -0.160873,0.0436 -0.52488,0.397463 -0.479803,0.466432 -0.78924,0.689475 -1.355603,0.977118 -0.183693,0.0933 -0.323426,0.179989 -0.310516,0.192658 0.02801,0.02748 -0.7656391,0.270031 -1.209129,0.369517 -0.5378332,0.120647 -1.6341809,0.08626 -1.9721503,-0.06186 C 6.7977157,23.031391 6.56735,22.957551 6.3371134,22.889782 4.9717169,22.487902 3.7511914,21.481518 3.1172396,20.234838 2.6890391,19.392772 2.5582276,18.827446 2.5610489,17.831154 2.5639589,16.802192 2.7366641,16.125844 3.2142117,15.273187 3.3040457,15.112788 3.3713143,14.976533 3.3636956,14.9704 3.3560756,14.9643 3.2459634,14.90305 3.1189994,14.834381 1.7582586,14.098312 0.77760984,12.777439 0.44909837,11.23818 0.33531456,10.705039 0.33670119,9.7067968 0.45195381,9.1778795 0.72259241,7.9359287 1.3827188,6.8888436 2.4297498,6.0407205 2.6856126,5.8334648 3.2975489,5.4910878 3.6885849,5.3364049 L 4.0584319,5.190106 4.2333984,4.860432 C 4.8393906,3.7186139 5.8908314,2.7968028 7.1056396,2.3423025 7.7690673,2.0940921 8.2290216,2.0150935 9.01853,2.0137575 c 0.9625627,-0.00163 1.629181,0.1532762 2.485864,0.5776514 l 0.271744,0.1346134 0.42911,-0.3607688 c 1.082666,-0.9102346 2.185531,-1.3136811 3.578383,-1.3090327 0.916696,0.00306 1.573918,0.1517893 2.356121,0.5331927 1.465948,0.7148 2.54506,2.0625628 2.865177,3.57848 l 0.07653,0.362429 0.515095,0.2556611 c 1.022872,0.5076874 1.756122,1.1690944 2.288361,2.0641468 0.401896,0.6758594 0.537303,1.0442682 0.675505,1.8378683 0.288575,1.6570823 -0.266229,3.3548023 -1.490464,4.5608743 -0.371074,0.36557 -0.840205,0.718265 -1.203442,0.904754 -0.144112,0.07398 -0.271303,0.15826 -0.282647,0.187269 -0.01134,0.02901 0.02121,0.142764 0.07234,0.25279 0.184248,0.396467 0.451371,1.331823 0.619371,2.168779 0.463493,2.30908 -0.754646,4.693707 -2.92278,5.721632 -0.479538,0.227352 -0.717629,0.309322 -1.144194,0.39393 -0.321869,0.06383 -1.850573,0.09139 -2.000174,0.03604 z M 12.25443,18.636956 c 0.739923,-0.24652 1.382521,-0.718922 1.874623,-1.37812 0.0752,-0.100718 0.213883,-0.275851 0.308198,-0.389167 0.09432,-0.113318 0.210136,-0.271056 0.257381,-0.350531 0.416347,-0.700389 0.680936,-1.176102 0.766454,-1.378041 0.05594,-0.132087 0.114653,-0.239607 0.130477,-0.238929 0.01583,6.79e-4 0.08126,0.08531 0.145412,0.188069 0.178029,0.285173 0.614305,0.658998 0.868158,0.743878 0.259802,0.08686 0.656158,0.09598 0.911369,0.02095 0.213812,-0.06285 0.507296,-0.298016 0.645179,-0.516947 0.155165,-0.246374 0.327989,-0.989595 0.327989,-1.410501 0,-1.26718 -0.610975,-3.143405 -1.237774,-3.801045 -0.198483,-0.2082486 -0.208557,-0.2319396 -0.208557,-0.4904655 0,-0.2517771 -0.08774,-0.5704927 -0.258476,-0.938956 C 16.694963,8.50313 16.375697,8.1377479 16.135846,7.9543702 L 15.932296,7.7987471 15.683004,7.9356529 C 15.131767,8.2383821 14.435638,8.1945733 13.943459,7.8261812 L 13.782862,7.7059758 13.686773,7.8908012 C 13.338849,8.5600578 12.487087,8.8811064 11.743178,8.6233891 11.487199,8.5347109 11.358897,8.4505994 11.063189,8.1776138 L 10.69871,7.8411436 10.453484,8.0579255 C 10.318608,8.1771557 10.113778,8.3156283 9.9983037,8.3656417 9.7041488,8.4930449 9.1808299,8.5227884 8.8979004,8.4281886 8.7754792,8.3872574 8.6687415,8.3537661 8.6607053,8.3537661 c -0.03426,0 -0.3092864,0.3066098 -0.3791974,0.42275 -0.041935,0.069664 -0.1040482,0.1266636 -0.1380294,0.1266636 -0.1316419,0 -0.4197402,0.1843928 -0.6257041,0.4004735 -0.1923125,0.2017571 -0.6853701,0.9036038 -0.8926582,1.2706578 -0.042662,0.07554 -0.1803555,0.353687 -0.3059848,0.618091 -0.1256293,0.264406 -0.3270073,0.686768 -0.4475067,0.938581 -0.1204992,0.251816 -0.2469926,0.519654 -0.2810961,0.595199 -0.2592829,0.574347 -0.285919,1.391094 -0.057822,1.77304 0.1690683,0.283105 0.4224039,0.480895 0.7285507,0.568809 0.487122,0.139885 0.9109638,-0.004 1.6013422,-0.543768 l 0.4560939,-0.356568 0.0036,0.172041 c 0.01635,0.781837 0.1831084,1.813183 0.4016641,2.484154 0.1160449,0.356262 0.3781448,0.83968 0.5614081,1.035462 0.2171883,0.232025 0.7140951,0.577268 1.0100284,0.701749 0.121485,0.0511 0.351032,0.110795 0.510105,0.132647 0.396966,0.05452 1.2105,0.02265 1.448934,-0.05679 z"

     

       54
       +
              id="path1" />

     

       55
       +
         </g>

     

       56
       +
       </svg>

     

       57
       +
       {{ end }}

appview/pages/templates/fragments/logotypeSmall.html

···

       1
       +
       {{ define "fragments/logotypeSmall" }}

     

       2
       +
         <span class="flex items-center gap-2">

     

       3
       +
           {{ template "fragments/dolly/logo" "size-8 text-black dark:text-white" }}

     

       4
       +
           <span class="font-bold text-xl not-italic">tangled</span>

     

       5
       +
           <span class="font-normal not-italic text-xs rounded bg-gray-100 dark:bg-gray-700 px-1">

     

       6
       +
             alpha

     

       7
       +
           </span>

     

       8
       +
         <span>

     

       9
       +
       {{ end }}

+1 -1

appview/pages/templates/repo/commit.html

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := printf "commit %s &middot; %s" .Diff.Commit.This .RepoInfo.FullName }}

     

       5
       -
           {{ $url := printf "https://tangled.sh/%s/commit/%s" .RepoInfo.FullName .Diff.Commit.This }}

     

       6
        
       

     

       7
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       8
        
       {{ end }}

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := printf "commit %s &middot; %s" .Diff.Commit.This .RepoInfo.FullName }}

     

       5
       +
           {{ $url := printf "https://tangled.org/%s/commit/%s" .RepoInfo.FullName .Diff.Commit.This }}

     

       6
        
       

     

       7
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       8
        
       {{ end }}

+5 -5

appview/pages/templates/repo/fragments/meta.html

···

       1
        
       {{ define "repo/fragments/meta" }}

     

       2
        
           <meta

     

       3
        
               name="vcs:clone"

     

       4
       -
               content="https://tangled.sh/{{ .RepoInfo.FullName }}"

     

       5
        
           />

     

       6
        
           <meta

     

       7
        
               name="forge:summary"

     

       8
       -
               content="https://tangled.sh/{{ .RepoInfo.FullName }}"

     

       9
        
           />

     

       10
        
           <meta

     

       11
        
               name="forge:dir"

     

       12
       -
               content="https://tangled.sh/{{ .RepoInfo.FullName }}/tree/{ref}/{path}"

     

       13
        
           />

     

       14
        
           <meta

     

       15
        
               name="forge:file"

     

       16
       -
               content="https://tangled.sh/{{ .RepoInfo.FullName }}/blob/{ref}/{path}"

     

       17
        
           />

     

       18
        
           <meta

     

       19
        
               name="forge:line"

     

       20
       -
               content="https://tangled.sh/{{ .RepoInfo.FullName }}/blob/{ref}/{path}#L{line}"

     

       21
        
           />

     

       22
        
           <meta

     

       23
        
               name="go-import"

···

       1
        
       {{ define "repo/fragments/meta" }}

     

       2
        
           <meta

     

       3
        
               name="vcs:clone"

     

       4
       +
               content="https://tangled.org/{{ .RepoInfo.FullName }}"

     

       5
        
           />

     

       6
        
           <meta

     

       7
        
               name="forge:summary"

     

       8
       +
               content="https://tangled.org/{{ .RepoInfo.FullName }}"

     

       9
        
           />

     

       10
        
           <meta

     

       11
        
               name="forge:dir"

     

       12
       +
               content="https://tangled.org/{{ .RepoInfo.FullName }}/tree/{ref}/{path}"

     

       13
        
           />

     

       14
        
           <meta

     

       15
        
               name="forge:file"

     

       16
       +
               content="https://tangled.org/{{ .RepoInfo.FullName }}/blob/{ref}/{path}"

     

       17
        
           />

     

       18
        
           <meta

     

       19
        
               name="forge:line"

     

       20
       +
               content="https://tangled.org/{{ .RepoInfo.FullName }}/blob/{ref}/{path}#L{line}"

     

       21
        
           />

     

       22
        
           <meta

     

       23
        
               name="go-import"

+2 -2

appview/pages/templates/repo/pipelines/pipelines.html

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := "pipelines"}}

     

       5
       -
           {{ $url := printf "https://tangled.sh/%s/pipelines" .RepoInfo.FullName }}

     

       6
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       7
        
       {{ end }}

     

       8
        
       

     
···

       60
        
                   <span class="inline-flex gap-2 items-center">

     

       61
        
                     <span class="font-bold">{{ $target }}</span>

     

       62
        
                     {{ i "arrow-left" "size-4" }}

     

       63
       -
                     {{ .Trigger.PRSourceBranch }} 

     

       64
        
                     <span class="text-sm font-mono">

     

       65
        
                       @

     

       66
        
                       <a href="/{{ $root.RepoInfo.FullName }}/commit/{{ $sha }}">{{ slice $sha 0 8 }}</a>

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := "pipelines"}}

     

       5
       +
           {{ $url := printf "https://tangled.org/%s/pipelines" .RepoInfo.FullName }}

     

       6
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       7
        
       {{ end }}

     

       8
        
       

     
···

       60
        
                   <span class="inline-flex gap-2 items-center">

     

       61
        
                     <span class="font-bold">{{ $target }}</span>

     

       62
        
                     {{ i "arrow-left" "size-4" }}

     

       63
       +
                     {{ .Trigger.PRSourceBranch }}

     

       64
        
                     <span class="text-sm font-mono">

     

       65
        
                       @

     

       66
        
                       <a href="/{{ $root.RepoInfo.FullName }}/commit/{{ $sha }}">{{ slice $sha 0 8 }}</a>

+1 -1

appview/pages/templates/repo/pipelines/workflow.html

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := "pipelines"}}

     

       5
       -
           {{ $url := printf "https://tangled.sh/%s/pipelines" .RepoInfo.FullName }}

     

       6
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       7
        
       {{ end }}

     

       8

···

       2
        
       

     

       3
        
       {{ define "extrameta" }}

     

       4
        
           {{ $title := "pipelines"}}

     

       5
       +
           {{ $url := printf "https://tangled.org/%s/pipelines" .RepoInfo.FullName }}

     

       6
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       7
        
       {{ end }}

     

       8

+2 -2

appview/pages/templates/repo/pulls/interdiff.html

···

       5
        
       

     

       6
        
       {{ define "extrameta" }}

     

       7
        
           {{ $title := printf "interdiff of %d and %d &middot; %s &middot; pull #%d &middot; %s" .Round (sub .Round 1) .Pull.Title .Pull.PullId .RepoInfo.FullName }}

     

       8
       -
           {{ $url := printf "https://tangled.sh/%s/pulls/%d/round/%d" .RepoInfo.FullName .Pull.PullId .Round }}

     

       9
       -
           

     

       10
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" (unescapeHtml $title) "Url" $url) }}

     

       11
        
       {{ end }}

     

       12

···

       5
        
       

     

       6
        
       {{ define "extrameta" }}

     

       7
        
           {{ $title := printf "interdiff of %d and %d &middot; %s &middot; pull #%d &middot; %s" .Round (sub .Round 1) .Pull.Title .Pull.PullId .RepoInfo.FullName }}

     

       8
       +
           {{ $url := printf "https://tangled.org/%s/pulls/%d/round/%d" .RepoInfo.FullName .Pull.PullId .Round }}

     

       9
       +
       

     

       10
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" (unescapeHtml $title) "Url" $url) }}

     

       11
        
       {{ end }}

     

       12

+1 -1

appview/pages/templates/spindles/index.html

···

       5
        
           <h1 class="text-xl font-bold dark:text-white">Spindles</h1>

     

       6
        
           <span class="flex items-center gap-1">

     

       7
        
               {{ i "book" "w-3 h-3" }}

     

       8
       -
               <a href="https://tangled.sh/@tangled.sh/core/blob/master/docs/spindle/hosting.md">docs</a>

     

       9
        
           </span>

     

       10
        
       </div>

     

       11

···

       5
        
           <h1 class="text-xl font-bold dark:text-white">Spindles</h1>

     

       6
        
           <span class="flex items-center gap-1">

     

       7
        
               {{ i "book" "w-3 h-3" }}

     

       8
       +
               <a href="https://tangled.org/@tangled.org/core/blob/master/docs/spindle/hosting.md">docs</a>

     

       9
        
           </span>

     

       10
        
       </div>

     

       11

+1 -1

appview/pages/templates/strings/dashboard.html

···

       3
        
       {{ define "extrameta" }}

     

       4
        
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       5
        
           <meta property="og:type" content="profile" />

     

       6
       -
           <meta property="og:url" content="https://tangled.sh/{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       7
        
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       8
        
       {{ end }}

     

       9

···

       3
        
       {{ define "extrameta" }}

     

       4
        
           <meta property="og:title" content="{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       5
        
           <meta property="og:type" content="profile" />

     

       6
       +
           <meta property="og:url" content="https://tangled.org/{{ or .Card.UserHandle .Card.UserDid  }}" />

     

       7
        
           <meta property="og:description" content="{{ or .Card.Profile.Description .Card.UserHandle .Card.UserDid }}" />

     

       8
        
       {{ end }}

     

       9

+1 -1

appview/pages/templates/strings/string.html

···

       4
        
         {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       5
        
         <meta property="og:title" content="{{ .String.Filename }} · by {{ $ownerId }}" />

     

       6
        
         <meta property="og:type" content="object" />

     

       7
       -
         <meta property="og:url" content="https://tangled.sh/strings/{{ $ownerId }}/{{ .String.Rkey }}" />

     

       8
        
         <meta property="og:description" content="{{ .String.Description }}" />

     

       9
        
       {{ end }}

     

       10

···

       4
        
         {{ $ownerId := didOrHandle .Owner.DID.String .Owner.Handle.String }}

     

       5
        
         <meta property="og:title" content="{{ .String.Filename }} · by {{ $ownerId }}" />

     

       6
        
         <meta property="og:type" content="object" />

     

       7
       +
         <meta property="og:url" content="https://tangled.org/strings/{{ $ownerId }}/{{ .String.Rkey }}" />

     

       8
        
         <meta property="og:description" content="{{ .String.Description }}" />

     

       9
        
       {{ end }}

     

       10

+1 -2

appview/pages/templates/timeline/fragments/hero.html

···

       22
        
               </div>

     

       23
        
       

     

       24
        
               <figure class="w-full hidden md:block md:w-auto">

     

       25
       -
                   <a href="https://tangled.sh/@tangled.sh/core" class="block">

     

       26
        
                       <img src="https://assets.tangled.network/hero-repo.png" alt="Screenshot of the Tangled monorepo." class="max-w-md mx-auto md:max-w-none w-full md:w-[30vw] h-auto shadow-sm rounded" />

     

       27
        
                   </a>

     

       28
        
                   <figcaption class="text-sm text-gray-600 dark:text-gray-400 mt-2 text-center">

     
···

       31
        
               </figure>

     

       32
        
           </div>

     

       33
        
       {{ end }}

     

       34
       -

···

       22
        
               </div>

     

       23
        
       

     

       24
        
               <figure class="w-full hidden md:block md:w-auto">

     

       25
       +
                   <a href="https://tangled.org/@tangled.org/core" class="block">

     

       26
        
                       <img src="https://assets.tangled.network/hero-repo.png" alt="Screenshot of the Tangled monorepo." class="max-w-md mx-auto md:max-w-none w-full md:w-[30vw] h-auto shadow-sm rounded" />

     

       27
        
                   </a>

     

       28
        
                   <figcaption class="text-sm text-gray-600 dark:text-gray-400 mt-2 text-center">

     
···

       31
        
               </figure>

     

       32
        
           </div>

     

       33
        
       {{ end }}

     

       0

+1 -2

appview/pages/templates/timeline/home.html

···

       3
        
       {{ define "extrameta" }}

     

       4
        
           <meta property="og:title" content="timeline · tangled" />

     

       5
        
           <meta property="og:type" content="object" />

     

       6
       -
           <meta property="og:url" content="https://tangled.sh" />

     

       7
        
           <meta property="og:description" content="tightly-knit social coding" />

     

       8
        
       {{ end }}

     

       9
        
       

     
···

       87
        
           ) }}

     

       88
        
         </div>

     

       89
        
       {{ end }}

     

       90
       -

···

       3
        
       {{ define "extrameta" }}

     

       4
        
           <meta property="og:title" content="timeline · tangled" />

     

       5
        
           <meta property="og:type" content="object" />

     

       6
       +
           <meta property="og:url" content="https://tangled.org" />

     

       7
        
           <meta property="og:description" content="tightly-knit social coding" />

     

       8
        
       {{ end }}

     

       9
        
       

     
···

       87
        
           ) }}

     

       88
        
         </div>

     

       89
        
       {{ end }}

     

       0

+1 -1

appview/cache/session/store.go

···

       6
        
       	"fmt"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       -
       	"tangled.sh/tangled.sh/core/appview/cache"

     

       10
        
       )

     

       11
        
       

     

       12
        
       type OAuthSession struct {

···

       6
        
       	"fmt"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       +
       	"tangled.org/core/appview/cache"

     

       10
        
       )

     

       11
        
       

     

       12
        
       type OAuthSession struct {

+4 -4

appview/oauth/oauth.go

···

       9
        
       

     

       10
        
       	indigo_xrpc "github.com/bluesky-social/indigo/xrpc"

     

       11
        
       	"github.com/gorilla/sessions"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       	oauth "tangled.sh/icyphox.sh/atproto-oauth"

     

       13
        
       	"tangled.sh/icyphox.sh/atproto-oauth/helpers"

     

       14
       -
       	sessioncache "tangled.sh/tangled.sh/core/appview/cache/session"

     

       15
       -
       	"tangled.sh/tangled.sh/core/appview/config"

     

       16
       -
       	"tangled.sh/tangled.sh/core/appview/oauth/client"

     

       17
       -
       	xrpc "tangled.sh/tangled.sh/core/appview/xrpcclient"

     

       18
        
       )

     

       19
        
       

     

       20
        
       type OAuth struct {

···

       9
        
       

     

       10
        
       	indigo_xrpc "github.com/bluesky-social/indigo/xrpc"

     

       11
        
       	"github.com/gorilla/sessions"

     

       12
       +
       	sessioncache "tangled.org/core/appview/cache/session"

     

       13
       +
       	"tangled.org/core/appview/config"

     

       14
       +
       	"tangled.org/core/appview/oauth/client"

     

       15
       +
       	xrpc "tangled.org/core/appview/xrpcclient"

     

       16
        
       	oauth "tangled.sh/icyphox.sh/atproto-oauth"

     

       17
        
       	"tangled.sh/icyphox.sh/atproto-oauth/helpers"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       )

     

       19
        
       

     

       20
        
       type OAuth struct {

+1 -1

appview/pipelines/router.go

···

       4
        
       	"net/http"

     

       5
        
       

     

       6
        
       	"github.com/go-chi/chi/v5"

     

       7
       -
       	"tangled.sh/tangled.sh/core/appview/middleware"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (p *Pipelines) Router(mw *middleware.Middleware) http.Handler {

···

       4
        
       	"net/http"

     

       5
        
       

     

       6
        
       	"github.com/go-chi/chi/v5"

     

       7
       +
       	"tangled.org/core/appview/middleware"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (p *Pipelines) Router(mw *middleware.Middleware) http.Handler {

+1 -1

appview/pulls/router.go

···

       4
        
       	"net/http"

     

       5
        
       

     

       6
        
       	"github.com/go-chi/chi/v5"

     

       7
       -
       	"tangled.sh/tangled.sh/core/appview/middleware"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (s *Pulls) Router(mw *middleware.Middleware) http.Handler {

···

       4
        
       	"net/http"

     

       5
        
       

     

       6
        
       	"github.com/go-chi/chi/v5"

     

       7
       +
       	"tangled.org/core/appview/middleware"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (s *Pulls) Router(mw *middleware.Middleware) http.Handler {

+4 -4

appview/serververify/verify.go

···

       6
        
       	"fmt"

     

       7
        
       

     

       8
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       9
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       10
       -
       	"tangled.sh/tangled.sh/core/appview/db"

     

       11
       -
       	"tangled.sh/tangled.sh/core/appview/xrpcclient"

     

       12
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       13
        
       )

     

       14
        
       

     

       15
        
       var (

···

       6
        
       	"fmt"

     

       7
        
       

     

       8
        
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       +
       	"tangled.org/core/appview/db"

     

       11
       +
       	"tangled.org/core/appview/xrpcclient"

     

       12
       +
       	"tangled.org/core/rbac"

     

       13
        
       )

     

       14
        
       

     

       15
        
       var (

+1 -1

cmd/combinediff/main.go

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       8
       -
       	"tangled.sh/tangled.sh/core/patchutil"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func main() {

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       8
       +
       	"tangled.org/core/patchutil"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func main() {

+1 -1

cmd/interdiff/main.go

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       8
       -
       	"tangled.sh/tangled.sh/core/patchutil"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func main() {

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       8
       +
       	"tangled.org/core/patchutil"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func main() {

+5 -5

cmd/knot/main.go

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/urfave/cli/v3"

     

       8
       -
       	"tangled.sh/tangled.sh/core/guard"

     

       9
       -
       	"tangled.sh/tangled.sh/core/hook"

     

       10
       -
       	"tangled.sh/tangled.sh/core/keyfetch"

     

       11
       -
       	"tangled.sh/tangled.sh/core/knotserver"

     

       12
       -
       	"tangled.sh/tangled.sh/core/log"

     

       13
        
       )

     

       14
        
       

     

       15
        
       func main() {

···

       5
        
       	"os"

     

       6
        
       

     

       7
        
       	"github.com/urfave/cli/v3"

     

       8
       +
       	"tangled.org/core/guard"

     

       9
       +
       	"tangled.org/core/hook"

     

       10
       +
       	"tangled.org/core/keyfetch"

     

       11
       +
       	"tangled.org/core/knotserver"

     

       12
       +
       	"tangled.org/core/log"

     

       13
        
       )

     

       14
        
       

     

       15
        
       func main() {

+2 -2

docs/knot-hosting.md

···

       19
        
       First, clone this repository:

     

       20
        
       

     

       21
        
       ```

     

       22
       -
       git clone https://tangled.sh/@tangled.sh/core

     

       23
        
       ```

     

       24
        
       

     

       25
        
       Then, build the `knot` CLI. This is the knot administration and operation tool.

     
···

       130
        
       

     

       131
        
       You should now have a running knot server! You can finalize

     

       132
        
       your registration by hitting the `verify` button on the

     

       133
       -
       [/knots](https://tangled.sh/knots) page. This simply creates

     

       134
        
       a record on your PDS to announce the existence of the knot.

     

       135
        
       

     

       136
        
       ### custom paths

···

       19
        
       First, clone this repository:

     

       20
        
       

     

       21
        
       ```

     

       22
       +
       git clone https://tangled.org/@tangled.org/core

     

       23
        
       ```

     

       24
        
       

     

       25
        
       Then, build the `knot` CLI. This is the knot administration and operation tool.

     
···

       130
        
       

     

       131
        
       You should now have a running knot server! You can finalize

     

       132
        
       your registration by hitting the `verify` button on the

     

       133
       +
       [/knots](https://tangled.org/knots) page. This simply creates

     

       134
        
       a record on your PDS to announce the existence of the knot.

     

       135
        
       

     

       136
        
       ### custom paths

+4 -5

docs/migrations.md

···

       14
        
       For knots:

     

       15
        
       

     

       16
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       17
       -
       - Head to the [knot dashboard](https://tangled.sh/knots) and

     

       18
        
         hit the "retry" button to verify your knot

     

       19
        
       

     

       20
        
       For spindles:

     

       21
        
       

     

       22
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       23
        
       - Head to the [spindle

     

       24
       -
         dashboard](https://tangled.sh/spindles) and hit the

     

       25
        
         "retry" button to verify your spindle

     

       26
        
       

     

       27
        
       ## Upgrading from v1.7.x

     
···

       38
        
         environment variable entirely

     

       39
        
       - `KNOT_SERVER_OWNER` is now required on boot, set this to

     

       40
        
         your DID. You can find your DID in the

     

       41
       -
         [settings](https://tangled.sh/settings) page.

     

       42
        
       - Restart your knot once you have replaced the environment

     

       43
        
         variable

     

       44
       -
       - Head to the [knot dashboard](https://tangled.sh/knots) and

     

       45
        
         hit the "retry" button to verify your knot. This simply

     

       46
        
         writes a `sh.tangled.knot` record to your PDS.

     

       47
        
       

     
···

       57
        
          };

     

       58
        
        };

     

       59
        
       ```

     

       60
       -

···

       14
        
       For knots:

     

       15
        
       

     

       16
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       17
       +
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       18
        
         hit the "retry" button to verify your knot

     

       19
        
       

     

       20
        
       For spindles:

     

       21
        
       

     

       22
        
       - Upgrade to latest tag (v1.9.0 or above)

     

       23
        
       - Head to the [spindle

     

       24
       +
         dashboard](https://tangled.org/spindles) and hit the

     

       25
        
         "retry" button to verify your spindle

     

       26
        
       

     

       27
        
       ## Upgrading from v1.7.x

     
···

       38
        
         environment variable entirely

     

       39
        
       - `KNOT_SERVER_OWNER` is now required on boot, set this to

     

       40
        
         your DID. You can find your DID in the

     

       41
       +
         [settings](https://tangled.org/settings) page.

     

       42
        
       - Restart your knot once you have replaced the environment

     

       43
        
         variable

     

       44
       +
       - Head to the [knot dashboard](https://tangled.org/knots) and

     

       45
        
         hit the "retry" button to verify your knot. This simply

     

       46
        
         writes a `sh.tangled.knot` record to your PDS.

     

       47
        
       

     
···

       57
        
          };

     

       58
        
        };

     

       59
        
       ```

     

       0

+1 -1

keyfetch/keyfetch.go

···

       10
        
       	"strings"

     

       11
        
       

     

       12
        
       	"github.com/urfave/cli/v3"

     

       13
       -
       	"tangled.sh/tangled.sh/core/log"

     

       14
        
       )

     

       15
        
       

     

       16
        
       func Command() *cli.Command {

···

       10
        
       	"strings"

     

       11
        
       

     

       12
        
       	"github.com/urfave/cli/v3"

     

       13
       +
       	"tangled.org/core/log"

     

       14
        
       )

     

       15
        
       

     

       16
        
       func Command() *cli.Command {

+1 -1

knotserver/db/events.go

···

       4
        
       	"fmt"

     

       5
        
       	"time"

     

       6
        
       

     

       7
       -
       	"tangled.sh/tangled.sh/core/notifier"

     

       8
        
       )

     

       9
        
       

     

       10
        
       type Event struct {

···

       4
        
       	"fmt"

     

       5
        
       	"time"

     

       6
        
       

     

       7
       +
       	"tangled.org/core/notifier"

     

       8
        
       )

     

       9
        
       

     

       10
        
       type Event struct {

+2 -2

knotserver/git/diff.go

···

       12
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       13
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       14
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       15
       -
       	"tangled.sh/tangled.sh/core/patchutil"

     

       16
       -
       	"tangled.sh/tangled.sh/core/types"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (g *GitRepo) Diff() (*types.NiceDiff, error) {

···

       12
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       13
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       14
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       15
       +
       	"tangled.org/core/patchutil"

     

       16
       +
       	"tangled.org/core/types"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (g *GitRepo) Diff() (*types.NiceDiff, error) {

+1 -1

knotserver/git/post_receive.go

···

       9
        
       	"strings"

     

       10
        
       	"time"

     

       11
        
       

     

       12
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       13
        
       

     

       14
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       15
        
       )

···

       9
        
       	"strings"

     

       10
        
       	"time"

     

       11
        
       

     

       12
       +
       	"tangled.org/core/api/tangled"

     

       13
        
       

     

       14
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       15
        
       )

+1 -1

knotserver/git/tree.go

···

       8
        
       	"time"

     

       9
        
       

     

       10
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       11
       -
       	"tangled.sh/tangled.sh/core/types"

     

       12
        
       )

     

       13
        
       

     

       14
        
       func (g *GitRepo) FileTree(ctx context.Context, path string) ([]types.NiceTree, error) {

···

       8
        
       	"time"

     

       9
        
       

     

       10
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       11
       +
       	"tangled.org/core/types"

     

       12
        
       )

     

       13
        
       

     

       14
        
       func (g *GitRepo) FileTree(ctx context.Context, path string) ([]types.NiceTree, error) {

+8 -8

knotserver/internal.go

···

       13
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
        
       	"github.com/go-chi/chi/v5"

     

       15
        
       	"github.com/go-chi/chi/v5/middleware"

     

       16
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       17
       -
       	"tangled.sh/tangled.sh/core/hook"

     

       18
       -
       	"tangled.sh/tangled.sh/core/knotserver/config"

     

       19
       -
       	"tangled.sh/tangled.sh/core/knotserver/db"

     

       20
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       21
       -
       	"tangled.sh/tangled.sh/core/notifier"

     

       22
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       23
       -
       	"tangled.sh/tangled.sh/core/workflow"

     

       24
        
       )

     

       25
        
       

     

       26
        
       type InternalHandle struct {

···

       13
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
        
       	"github.com/go-chi/chi/v5"

     

       15
        
       	"github.com/go-chi/chi/v5/middleware"

     

       16
       +
       	"tangled.org/core/api/tangled"

     

       17
       +
       	"tangled.org/core/hook"

     

       18
       +
       	"tangled.org/core/knotserver/config"

     

       19
       +
       	"tangled.org/core/knotserver/db"

     

       20
       +
       	"tangled.org/core/knotserver/git"

     

       21
       +
       	"tangled.org/core/notifier"

     

       22
       +
       	"tangled.org/core/rbac"

     

       23
       +
       	"tangled.org/core/workflow"

     

       24
        
       )

     

       25
        
       

     

       26
        
       type InternalHandle struct {

+3 -3

knotserver/xrpc/delete_repo.go

···

       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       13
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       15
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       16
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (x *Xrpc) DeleteRepo(w http.ResponseWriter, r *http.Request) {

···

       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       13
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
       +
       	"tangled.org/core/api/tangled"

     

       15
       +
       	"tangled.org/core/rbac"

     

       16
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (x *Xrpc) DeleteRepo(w http.ResponseWriter, r *http.Request) {

+2 -2

knotserver/xrpc/list_keys.go

···

       4
        
       	"net/http"

     

       5
        
       	"strconv"

     

       6
        
       

     

       7
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       8
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func (x *Xrpc) ListKeys(w http.ResponseWriter, r *http.Request) {

···

       4
        
       	"net/http"

     

       5
        
       	"strconv"

     

       6
        
       

     

       7
       +
       	"tangled.org/core/api/tangled"

     

       8
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func (x *Xrpc) ListKeys(w http.ResponseWriter, r *http.Request) {

+6 -6

knotserver/xrpc/merge.go

···

       8
        
       

     

       9
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       11
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       12
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       13
       -
       	"tangled.sh/tangled.sh/core/patchutil"

     

       14
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       15
       -
       	"tangled.sh/tangled.sh/core/types"

     

       16
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (x *Xrpc) Merge(w http.ResponseWriter, r *http.Request) {

···

       8
        
       

     

       9
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       11
       +
       	"tangled.org/core/api/tangled"

     

       12
       +
       	"tangled.org/core/knotserver/git"

     

       13
       +
       	"tangled.org/core/patchutil"

     

       14
       +
       	"tangled.org/core/rbac"

     

       15
       +
       	"tangled.org/core/types"

     

       16
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       17
        
       )

     

       18
        
       

     

       19
        
       func (x *Xrpc) Merge(w http.ResponseWriter, r *http.Request) {

+2 -2

knotserver/xrpc/owner.go

···

       3
        
       import (

     

       4
        
       	"net/http"

     

       5
        
       

     

       6
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       7
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (x *Xrpc) Owner(w http.ResponseWriter, r *http.Request) {

···

       3
        
       import (

     

       4
        
       	"net/http"

     

       5
        
       

     

       6
       +
       	"tangled.org/core/api/tangled"

     

       7
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       8
        
       )

     

       9
        
       

     

       10
        
       func (x *Xrpc) Owner(w http.ResponseWriter, r *http.Request) {

+3 -3

knotserver/xrpc/repo_branch.go

···

       5
        
       	"net/url"

     

       6
        
       	"time"

     

       7
        
       

     

       8
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       10
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       11
        
       )

     

       12
        
       

     

       13
        
       func (x *Xrpc) RepoBranch(w http.ResponseWriter, r *http.Request) {

···

       5
        
       	"net/url"

     

       6
        
       	"time"

     

       7
        
       

     

       8
       +
       	"tangled.org/core/api/tangled"

     

       9
       +
       	"tangled.org/core/knotserver/git"

     

       10
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       11
        
       )

     

       12
        
       

     

       13
        
       func (x *Xrpc) RepoBranch(w http.ResponseWriter, r *http.Request) {

+3 -3

knotserver/xrpc/repo_compare.go

···

       4
        
       	"fmt"

     

       5
        
       	"net/http"

     

       6
        
       

     

       7
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       8
       -
       	"tangled.sh/tangled.sh/core/types"

     

       9
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       10
        
       )

     

       11
        
       

     

       12
        
       func (x *Xrpc) RepoCompare(w http.ResponseWriter, r *http.Request) {

···

       4
        
       	"fmt"

     

       5
        
       	"net/http"

     

       6
        
       

     

       7
       +
       	"tangled.org/core/knotserver/git"

     

       8
       +
       	"tangled.org/core/types"

     

       9
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       10
        
       )

     

       11
        
       

     

       12
        
       func (x *Xrpc) RepoCompare(w http.ResponseWriter, r *http.Request) {

+3 -3

knotserver/xrpc/repo_diff.go

···

       3
        
       import (

     

       4
        
       	"net/http"

     

       5
        
       

     

       6
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       7
       -
       	"tangled.sh/tangled.sh/core/types"

     

       8
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func (x *Xrpc) RepoDiff(w http.ResponseWriter, r *http.Request) {

···

       3
        
       import (

     

       4
        
       	"net/http"

     

       5
        
       

     

       6
       +
       	"tangled.org/core/knotserver/git"

     

       7
       +
       	"tangled.org/core/types"

     

       8
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       9
        
       )

     

       10
        
       

     

       11
        
       func (x *Xrpc) RepoDiff(w http.ResponseWriter, r *http.Request) {

+3 -3

knotserver/xrpc/repo_languages.go

···

       6
        
       	"net/http"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       10
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       11
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       12
        
       )

     

       13
        
       

     

       14
        
       func (x *Xrpc) RepoLanguages(w http.ResponseWriter, r *http.Request) {

···

       6
        
       	"net/http"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       +
       	"tangled.org/core/knotserver/git"

     

       11
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       12
        
       )

     

       13
        
       

     

       14
        
       func (x *Xrpc) RepoLanguages(w http.ResponseWriter, r *http.Request) {

+3 -3

knotserver/xrpc/repo_tags.go

···

       7
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       8
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       9
        
       

     

       10
       -
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       11
       -
       	"tangled.sh/tangled.sh/core/types"

     

       12
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       13
        
       )

     

       14
        
       

     

       15
        
       func (x *Xrpc) RepoTags(w http.ResponseWriter, r *http.Request) {

···

       7
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       8
        
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       9
        
       

     

       10
       +
       	"tangled.org/core/knotserver/git"

     

       11
       +
       	"tangled.org/core/types"

     

       12
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       13
        
       )

     

       14
        
       

     

       15
        
       func (x *Xrpc) RepoTags(w http.ResponseWriter, r *http.Request) {

+2 -2

knotserver/xrpc/version.go

···

       5
        
       	"net/http"

     

       6
        
       	"runtime/debug"

     

       7
        
       

     

       8
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
        
       )

     

       10
        
       

     

       11
        
       // version is set during build time.

     
···

       24
        
       		var modified bool

     

       25
        
       

     

       26
        
       		for _, mod := range info.Deps {

     

       27
       -
       			if mod.Path == "tangled.sh/tangled.sh/knotserver/xrpc" {

     

       28
        
       				modVer = mod.Version

     

       29
        
       				break

     

       30
        
       			}

···

       5
        
       	"net/http"

     

       6
        
       	"runtime/debug"

     

       7
        
       

     

       8
       +
       	"tangled.org/core/api/tangled"

     

       9
        
       )

     

       10
        
       

     

       11
        
       // version is set during build time.

     
···

       24
        
       		var modified bool

     

       25
        
       

     

       26
        
       		for _, mod := range info.Deps {

     

       27
       +
       			if mod.Path == "tangled.org/tangled.org/knotserver/xrpc" {

     

       28
        
       				modVer = mod.Version

     

       29
        
       				break

     

       30
        
       			}

+9 -9

knotserver/xrpc/xrpc.go

···

       7
        
       	"strings"

     

       8
        
       

     

       9
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       11
       -
       	"tangled.sh/tangled.sh/core/idresolver"

     

       12
       -
       	"tangled.sh/tangled.sh/core/jetstream"

     

       13
       -
       	"tangled.sh/tangled.sh/core/knotserver/config"

     

       14
       -
       	"tangled.sh/tangled.sh/core/knotserver/db"

     

       15
       -
       	"tangled.sh/tangled.sh/core/notifier"

     

       16
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       17
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       18
       -
       	"tangled.sh/tangled.sh/core/xrpc/serviceauth"

     

       19
        
       

     

       20
        
       	"github.com/go-chi/chi/v5"

     

       21
        
       )

···

       7
        
       	"strings"

     

       8
        
       

     

       9
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
       +
       	"tangled.org/core/api/tangled"

     

       11
       +
       	"tangled.org/core/idresolver"

     

       12
       +
       	"tangled.org/core/jetstream"

     

       13
       +
       	"tangled.org/core/knotserver/config"

     

       14
       +
       	"tangled.org/core/knotserver/db"

     

       15
       +
       	"tangled.org/core/notifier"

     

       16
       +
       	"tangled.org/core/rbac"

     

       17
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       18
       +
       	"tangled.org/core/xrpc/serviceauth"

     

       19
        
       

     

       20
        
       	"github.com/go-chi/chi/v5"

     

       21
        
       )

+1 -1

lexicon-build-config.json

···

       3
        
           "package": "tangled",

     

       4
        
           "prefix": "sh.tangled",

     

       5
        
           "outdir": "api/tangled",

     

       6
       -
           "import": "tangled.sh/tangled.sh/core/api/tangled",

     

       7
        
           "gen-server": true

     

       8
        
         }

     

       9
        
       ]

···

       3
        
           "package": "tangled",

     

       4
        
           "prefix": "sh.tangled",

     

       5
        
           "outdir": "api/tangled",

     

       6
       +
           "import": "tangled.org/core/api/tangled",

     

       7
        
           "gen-server": true

     

       8
        
         }

     

       9
        
       ]

+1 -1

patchutil/patchutil.go

···

       10
        
       	"strings"

     

       11
        
       

     

       12
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       13
       -
       	"tangled.sh/tangled.sh/core/types"

     

       14
        
       )

     

       15
        
       

     

       16
        
       func ExtractPatches(formatPatch string) ([]types.FormatPatch, error) {

···

       10
        
       	"strings"

     

       11
        
       

     

       12
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       13
       +
       	"tangled.org/core/types"

     

       14
        
       )

     

       15
        
       

     

       16
        
       func ExtractPatches(formatPatch string) ([]types.FormatPatch, error) {

+4 -4

spindle/db/events.go

···

       5
        
       	"fmt"

     

       6
        
       	"time"

     

       7
        
       

     

       8
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       -
       	"tangled.sh/tangled.sh/core/notifier"

     

       10
       -
       	"tangled.sh/tangled.sh/core/spindle/models"

     

       11
       -
       	"tangled.sh/tangled.sh/core/tid"

     

       12
        
       )

     

       13
        
       

     

       14
        
       type Event struct {

···

       5
        
       	"fmt"

     

       6
        
       	"time"

     

       7
        
       

     

       8
       +
       	"tangled.org/core/api/tangled"

     

       9
       +
       	"tangled.org/core/notifier"

     

       10
       +
       	"tangled.org/core/spindle/models"

     

       11
       +
       	"tangled.org/core/tid"

     

       12
        
       )

     

       13
        
       

     

       14
        
       type Event struct {

+5 -5

spindle/engine/engine.go

···

       8
        
       

     

       9
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
        
       	"golang.org/x/sync/errgroup"

     

       11
       -
       	"tangled.sh/tangled.sh/core/notifier"

     

       12
       -
       	"tangled.sh/tangled.sh/core/spindle/config"

     

       13
       -
       	"tangled.sh/tangled.sh/core/spindle/db"

     

       14
       -
       	"tangled.sh/tangled.sh/core/spindle/models"

     

       15
       -
       	"tangled.sh/tangled.sh/core/spindle/secrets"

     

       16
        
       )

     

       17
        
       

     

       18
        
       var (

···

       8
        
       

     

       9
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
        
       	"golang.org/x/sync/errgroup"

     

       11
       +
       	"tangled.org/core/notifier"

     

       12
       +
       	"tangled.org/core/spindle/config"

     

       13
       +
       	"tangled.org/core/spindle/db"

     

       14
       +
       	"tangled.org/core/spindle/models"

     

       15
       +
       	"tangled.org/core/spindle/secrets"

     

       16
        
       )

     

       17
        
       

     

       18
        
       var (

+2 -2

spindle/engines/nixery/setup_steps.go

···

       5
        
       	"path"

     

       6
        
       	"strings"

     

       7
        
       

     

       8
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       -
       	"tangled.sh/tangled.sh/core/workflow"

     

       10
        
       )

     

       11
        
       

     

       12
        
       func nixConfStep() Step {

···

       5
        
       	"path"

     

       6
        
       	"strings"

     

       7
        
       

     

       8
       +
       	"tangled.org/core/api/tangled"

     

       9
       +
       	"tangled.org/core/workflow"

     

       10
        
       )

     

       11
        
       

     

       12
        
       func nixConfStep() Step {

+1 -1

spindle/stream.go

···

       10
        
       	"strconv"

     

       11
        
       	"time"

     

       12
        
       

     

       13
       -
       	"tangled.sh/tangled.sh/core/spindle/models"

     

       14
        
       

     

       15
        
       	"github.com/go-chi/chi/v5"

     

       16
        
       	"github.com/gorilla/websocket"

···

       10
        
       	"strconv"

     

       11
        
       	"time"

     

       12
        
       

     

       13
       +
       	"tangled.org/core/spindle/models"

     

       14
        
       

     

       15
        
       	"github.com/go-chi/chi/v5"

     

       16
        
       	"github.com/gorilla/websocket"

+9 -9

spindle/xrpc/xrpc.go

···

       8
        
       

     

       9
        
       	"github.com/go-chi/chi/v5"

     

       10
        
       

     

       11
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       12
       -
       	"tangled.sh/tangled.sh/core/idresolver"

     

       13
       -
       	"tangled.sh/tangled.sh/core/rbac"

     

       14
       -
       	"tangled.sh/tangled.sh/core/spindle/config"

     

       15
       -
       	"tangled.sh/tangled.sh/core/spindle/db"

     

       16
       -
       	"tangled.sh/tangled.sh/core/spindle/models"

     

       17
       -
       	"tangled.sh/tangled.sh/core/spindle/secrets"

     

       18
       -
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       19
       -
       	"tangled.sh/tangled.sh/core/xrpc/serviceauth"

     

       20
        
       )

     

       21
        
       

     

       22
        
       const ActorDid string = "ActorDid"

···

       8
        
       

     

       9
        
       	"github.com/go-chi/chi/v5"

     

       10
        
       

     

       11
       +
       	"tangled.org/core/api/tangled"

     

       12
       +
       	"tangled.org/core/idresolver"

     

       13
       +
       	"tangled.org/core/rbac"

     

       14
       +
       	"tangled.org/core/spindle/config"

     

       15
       +
       	"tangled.org/core/spindle/db"

     

       16
       +
       	"tangled.org/core/spindle/models"

     

       17
       +
       	"tangled.org/core/spindle/secrets"

     

       18
       +
       	xrpcerr "tangled.org/core/xrpc/errors"

     

       19
       +
       	"tangled.org/core/xrpc/serviceauth"

     

       20
        
       )

     

       21
        
       

     

       22
        
       const ActorDid string = "ActorDid"

+1 -1

workflow/def.go

···

       6
        
       	"slices"

     

       7
        
       	"strings"

     

       8
        
       

     

       9
       -
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       10
        
       

     

       11
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       12
        
       	"gopkg.in/yaml.v3"

···

       6
        
       	"slices"

     

       7
        
       	"strings"

     

       8
        
       

     

       9
       +
       	"tangled.org/core/api/tangled"

     

       10
        
       

     

       11
        
       	"github.com/go-git/go-git/v5/plumbing"

     

       12
        
       	"gopkg.in/yaml.v3"

+42

api/tangled/labeldefinition.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.label.definition

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	LabelDefinitionNSID = "sh.tangled.label.definition"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.label.definition", &LabelDefinition{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: LabelDefinition

     

       19
       +
       type LabelDefinition struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.label.definition" cborgen:"$type,const=sh.tangled.label.definition"`

     

       21
       +
       	// color: The hex value for the background color for the label. Appviews may choose to respect this.

     

       22
       +
       	Color     *string `json:"color,omitempty" cborgen:"color,omitempty"`

     

       23
       +
       	CreatedAt string  `json:"createdAt" cborgen:"createdAt"`

     

       24
       +
       	// multiple: Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]

     

       25
       +
       	Multiple *bool `json:"multiple,omitempty" cborgen:"multiple,omitempty"`

     

       26
       +
       	// name: The display name of this label.

     

       27
       +
       	Name string `json:"name" cborgen:"name"`

     

       28
       +
       	// scope: The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this.

     

       29
       +
       	Scope []string `json:"scope" cborgen:"scope"`

     

       30
       +
       	// valueType: The type definition of this label. Appviews may allow sorting for certain types.

     

       31
       +
       	ValueType *LabelDefinition_ValueType `json:"valueType" cborgen:"valueType"`

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       // LabelDefinition_ValueType is a "valueType" in the sh.tangled.label.definition schema.

     

       35
       +
       type LabelDefinition_ValueType struct {

     

       36
       +
       	// enum: Closed set of values that this label can take.

     

       37
       +
       	Enum []string `json:"enum,omitempty" cborgen:"enum,omitempty"`

     

       38
       +
       	// format: An optional constraint that can be applied on string concrete types.

     

       39
       +
       	Format string `json:"format" cborgen:"format"`

     

       40
       +
       	// type: The concrete type of this label's value.

     

       41
       +
       	Type string `json:"type" cborgen:"type"`

     

       42
       +
       }

+89

lexicons/label/definition.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.label.definition",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "any",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "name",

     

       14
       +
                 "valueType",

     

       15
       +
                 "scope",

     

       16
       +
                 "createdAt"

     

       17
       +
               ],

     

       18
       +
               "properties": {

     

       19
       +
                 "name": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "description": "The display name of this label.",

     

       22
       +
                   "minGraphemes": 1,

     

       23
       +
                   "maxGraphemes": 40

     

       24
       +
                 },

     

       25
       +
                 "valueType": {

     

       26
       +
                   "type": "ref",

     

       27
       +
                   "ref": "#valueType",

     

       28
       +
                   "description": "The type definition of this label. Appviews may allow sorting for certain types."

     

       29
       +
                 },

     

       30
       +
                 "scope": {

     

       31
       +
                   "type": "array",

     

       32
       +
                   "description": "The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this.",

     

       33
       +
                   "items": {

     

       34
       +
                     "type": "string",

     

       35
       +
                     "format": "nsid"

     

       36
       +
                   }

     

       37
       +
                 },

     

       38
       +
                 "color": {

     

       39
       +
                   "type": "string",

     

       40
       +
                   "description": "The hex value for the background color for the label. Appviews may choose to respect this."

     

       41
       +
                 },

     

       42
       +
                 "createdAt": {

     

       43
       +
                   "type": "string",

     

       44
       +
                   "format": "datetime"

     

       45
       +
                 },

     

       46
       +
                 "multiple": {

     

       47
       +
                   "type": "boolean",

     

       48
       +
                   "description": "Whether this label can be repeated for a given entity, eg.: [reviewer:foo, reviewer:bar]"

     

       49
       +
                 }

     

       50
       +
               }

     

       51
       +
             }

     

       52
       +
           },

     

       53
       +
           "valueType": {

     

       54
       +
             "type": "object",

     

       55
       +
             "required": [

     

       56
       +
               "type",

     

       57
       +
               "format"

     

       58
       +
             ],

     

       59
       +
             "properties": {

     

       60
       +
               "type": {

     

       61
       +
                 "type": "string",

     

       62
       +
                 "enum": [

     

       63
       +
                   "null",

     

       64
       +
                   "boolean",

     

       65
       +
                   "integer",

     

       66
       +
                   "string"

     

       67
       +
                 ],

     

       68
       +
                 "description": "The concrete type of this label's value."

     

       69
       +
               },

     

       70
       +
               "format": {

     

       71
       +
                 "type": "string",

     

       72
       +
                 "enum": [

     

       73
       +
                   "any",

     

       74
       +
                   "did",

     

       75
       +
                   "nsid"

     

       76
       +
                 ],

     

       77
       +
                 "description": "An optional constraint that can be applied on string concrete types."

     

       78
       +
               },

     

       79
       +
               "enum": {

     

       80
       +
                 "type": "array",

     

       81
       +
                 "description": "Closed set of values that this label can take.",

     

       82
       +
                 "items": {

     

       83
       +
                   "type": "string"

     

       84
       +
                 }

     

       85
       +
               }

     

       86
       +
             }

     

       87
       +
           }

     

       88
       +
         }

     

       89
       +
       }

+34

api/tangled/labelop.go

···

       1
       +
       // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.

     

       2
       +
       

     

       3
       +
       package tangled

     

       4
       +
       

     

       5
       +
       // schema: sh.tangled.label.op

     

       6
       +
       

     

       7
       +
       import (

     

       8
       +
       	"github.com/bluesky-social/indigo/lex/util"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	LabelOpNSID = "sh.tangled.label.op"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func init() {

     

       16
       +
       	util.RegisterType("sh.tangled.label.op", &LabelOp{})

     

       17
       +
       } //

     

       18
       +
       // RECORDTYPE: LabelOp

     

       19
       +
       type LabelOp struct {

     

       20
       +
       	LexiconTypeID string             `json:"$type,const=sh.tangled.label.op" cborgen:"$type,const=sh.tangled.label.op"`

     

       21
       +
       	Add           []*LabelOp_Operand `json:"add" cborgen:"add"`

     

       22
       +
       	Delete        []*LabelOp_Operand `json:"delete" cborgen:"delete"`

     

       23
       +
       	PerformedAt   string             `json:"performedAt" cborgen:"performedAt"`

     

       24
       +
       	// subject: The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op.

     

       25
       +
       	Subject string `json:"subject" cborgen:"subject"`

     

       26
       +
       }

     

       27
       +
       

     

       28
       +
       // LabelOp_Operand is a "operand" in the sh.tangled.label.op schema.

     

       29
       +
       type LabelOp_Operand struct {

     

       30
       +
       	// key: ATURI to the label definition

     

       31
       +
       	Key string `json:"key" cborgen:"key"`

     

       32
       +
       	// value: Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value.

     

       33
       +
       	Value string `json:"value" cborgen:"value"`

     

       34
       +
       }

cmd/gen.go

···

       28
        
       		tangled.KnotMember{},

     

       29
        
       		tangled.LabelDefinition{},

     

       30
        
       		tangled.LabelDefinition_ValueType{},

     

       0
        
       
     

       0
        
       
     

       31
        
       		tangled.Pipeline{},

     

       32
        
       		tangled.Pipeline_CloneOpts{},

     

       33
        
       		tangled.Pipeline_ManualTriggerData{},

···

       28
        
       		tangled.KnotMember{},

     

       29
        
       		tangled.LabelDefinition{},

     

       30
        
       		tangled.LabelDefinition_ValueType{},

     

       31
       +
       		tangled.LabelOp{},

     

       32
       +
       		tangled.LabelOp_Operand{},

     

       33
        
       		tangled.Pipeline{},

     

       34
        
       		tangled.Pipeline_CloneOpts{},

     

       35
        
       		tangled.Pipeline_ManualTriggerData{},

+64

lexicons/label/op.json

···

       1
       +
       {

     

       2
       +
         "lexicon": 1,

     

       3
       +
         "id": "sh.tangled.label.op",

     

       4
       +
         "needsCbor": true,

     

       5
       +
         "needsType": true,

     

       6
       +
         "defs": {

     

       7
       +
           "main": {

     

       8
       +
             "type": "record",

     

       9
       +
             "key": "tid",

     

       10
       +
             "record": {

     

       11
       +
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "add",

     

       15
       +
                 "delete",

     

       16
       +
                 "performedAt"

     

       17
       +
               ],

     

       18
       +
               "properties": {

     

       19
       +
                 "subject": {

     

       20
       +
                   "type": "string",

     

       21
       +
                   "format": "at-uri",

     

       22
       +
                   "description": "The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op."

     

       23
       +
                 },

     

       24
       +
                 "performedAt": {

     

       25
       +
                   "type": "string",

     

       26
       +
                   "format": "datetime"

     

       27
       +
                 },

     

       28
       +
                 "add": {

     

       29
       +
                   "type": "array",

     

       30
       +
                   "items": {

     

       31
       +
                     "type": "ref",

     

       32
       +
                     "ref": "#operand"

     

       33
       +
                   }

     

       34
       +
                 },

     

       35
       +
                 "delete": {

     

       36
       +
                   "type": "array",

     

       37
       +
                   "items": {

     

       38
       +
                     "type": "ref",

     

       39
       +
                     "ref": "#operand"

     

       40
       +
                   }

     

       41
       +
                 }

     

       42
       +
               }

     

       43
       +
             }

     

       44
       +
           },

     

       45
       +
           "operand": {

     

       46
       +
             "type": "object",

     

       47
       +
             "required": [

     

       48
       +
               "key",

     

       49
       +
               "value"

     

       50
       +
             ],

     

       51
       +
             "properties": {

     

       52
       +
               "key": {

     

       53
       +
                 "type": "string",

     

       54
       +
                 "format": "at-uri",

     

       55
       +
                 "description": "ATURI to the label definition"

     

       56
       +
               },

     

       57
       +
               "value": {

     

       58
       +
                 "type": "string",

     

       59
       +
                 "description": "Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value."

     

       60
       +
               }

     

       61
       +
             }

     

       62
       +
           }

     

       63
       +
         }

     

       64
       +
       }

-36

knotserver/util.go

···

       1
        
       package knotserver

     

       2
        
       

     

       3
        
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       	"os"

     

       6
       -
       	"path/filepath"

     

       7
       -
       

     

       8
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       -
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       10
       -
       	"github.com/go-chi/chi/v5"

     

       11
        
       )

     

       12
        
       

     

       13
       -
       func didPath(r *http.Request) string {

     

       14
       -
       	did := chi.URLParam(r, "did")

     

       15
       -
       	name := chi.URLParam(r, "name")

     

       16
       -
       	path, _ := securejoin.SecureJoin(did, name)

     

       17
       -
       	filepath.Clean(path)

     

       18
       -
       	return path

     

       19
       -
       }

     

       20
       -
       

     

       21
       -
       func getDescription(path string) (desc string) {

     

       22
       -
       	db, err := os.ReadFile(filepath.Join(path, "description"))

     

       23
       -
       	if err == nil {

     

       24
       -
       		desc = string(db)

     

       25
       -
       	} else {

     

       26
       -
       		desc = ""

     

       27
       -
       	}

     

       28
       -
       	return

     

       29
       -
       }

     

       30
       -
       func setContentDisposition(w http.ResponseWriter, name string) {

     

       31
       -
       	h := "inline; filename=\"" + name + "\""

     

       32
       -
       	w.Header().Add("Content-Disposition", h)

     

       33
       -
       }

     

       34
       -
       

     

       35
       -
       func setGZipMIME(w http.ResponseWriter) {

     

       36
       -
       	setMIME(w, "application/gzip")

     

       37
       -
       }

     

       38
       -
       

     

       39
       -
       func setMIME(w http.ResponseWriter, mime string) {

     

       40
       -
       	w.Header().Add("Content-Type", mime)

     

       41
       -
       }

     

       42
       -
       

     

       43
        
       var TIDClock = syntax.NewTIDClock(0)

     

       44
        
       

     

       45
        
       func TID() string {

···

       1
        
       package knotserver

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       0
        
       
     

       0
        
       
     

       5
        
       )

     

       6
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       var TIDClock = syntax.NewTIDClock(0)

     

       8
        
       

     

       9
        
       func TID() string {

+8 -5

lexicons/repo/repo.json

···

       12
        
               "required": [

     

       13
        
                 "name",

     

       14
        
                 "knot",

     

       15
       -
                 "owner",

     

       16
        
                 "createdAt"

     

       17
        
               ],

     

       18
        
               "properties": {

     
···

       20
        
                   "type": "string",

     

       21
        
                   "description": "name of the repo"

     

       22
        
                 },

     

       23
       -
                 "owner": {

     

       24
       -
                   "type": "string",

     

       25
       -
                   "format": "did"

     

       26
       -
                 },

     

       27
        
                 "knot": {

     

       28
        
                   "type": "string",

     

       29
        
                   "description": "knot where the repo was created"

     
···

       42
        
                   "format": "uri",

     

       43
        
                   "description": "source of the repo"

     

       44
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
                 "createdAt": {

     

       46
        
                   "type": "string",

     

       47
        
                   "format": "datetime"

···

       12
        
               "required": [

     

       13
        
                 "name",

     

       14
        
                 "knot",

     

       0
        
       
     

       15
        
                 "createdAt"

     

       16
        
               ],

     

       17
        
               "properties": {

     
···

       19
        
                   "type": "string",

     

       20
        
                   "description": "name of the repo"

     

       21
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
                 "knot": {

     

       23
        
                   "type": "string",

     

       24
        
                   "description": "knot where the repo was created"

     
···

       37
        
                   "format": "uri",

     

       38
        
                   "description": "source of the repo"

     

       39
        
                 },

     

       40
       +
                 "labels": {

     

       41
       +
                   "type": "array",

     

       42
       +
                   "description": "List of labels that this repo subscribes to",

     

       43
       +
                   "items": {

     

       44
       +
                     "type": "string",

     

       45
       +
                     "format": "at-uri"

     

       46
       +
                   }

     

       47
       +
                 },

     

       48
        
                 "createdAt": {

     

       49
        
                   "type": "string",

     

       50
        
                   "format": "datetime"

+1 -1

spindle/xrpc/add_secret.go

···

       62
        
       	}

     

       63
        
       

     

       64
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       65
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       66
        
       	if err != nil {

     

       67
        
       		fail(xrpcerr.GenericError(err))

     

       68
        
       		return

···

       62
        
       	}

     

       63
        
       

     

       64
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       65
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       66
        
       	if err != nil {

     

       67
        
       		fail(xrpcerr.GenericError(err))

     

       68
        
       		return

+1 -1

spindle/xrpc/list_secrets.go

···

       57
        
       	}

     

       58
        
       

     

       59
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       60
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       61
        
       	if err != nil {

     

       62
        
       		fail(xrpcerr.GenericError(err))

     

       63
        
       		return

···

       57
        
       	}

     

       58
        
       

     

       59
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       60
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       61
        
       	if err != nil {

     

       62
        
       		fail(xrpcerr.GenericError(err))

     

       63
        
       		return

+1 -1

spindle/xrpc/remove_secret.go

···

       56
        
       	}

     

       57
        
       

     

       58
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       59
       -
       	didPath, err := securejoin.SecureJoin(repo.Owner, repo.Name)

     

       60
        
       	if err != nil {

     

       61
        
       		fail(xrpcerr.GenericError(err))

     

       62
        
       		return

···

       56
        
       	}

     

       57
        
       

     

       58
        
       	repo := resp.Value.Val.(*tangled.Repo)

     

       59
       +
       	didPath, err := securejoin.SecureJoin(ident.DID.String(), repo.Name)

     

       60
        
       	if err != nil {

     

       61
        
       		fail(xrpcerr.GenericError(err))

     

       62
        
       		return

appview/pages/templates/repo/fragments/colorBall.html

···

       1
       +
       {{ define "repo/fragments/colorBall" }}

     

       2
       +
         <div

     

       3
       +
           class="size-2 rounded-full {{ .classes }}"

     

       4
       +
           style="background: radial-gradient(circle at 35% 35%, color-mix(in srgb, {{ .color }} 70%, white), {{ .color }} 30%, color-mix(in srgb, {{ .color }} 85%, black));"

     

       5
       +
         ></div>

     

       6
       +
       {{ end }}

+1 -1

appview/pages/templates/user/overview.html

···

       73
        
                   {{ with .Repo.RepoStats }}

     

       74
        
                     {{ with .Language }}

     

       75
        
                       <div class="flex gap-2 items-center text-xs font-mono text-gray-400 ">

     

       76
       -
                         {{ template "repo/fragments/languageBall" . }}

     

       77
        
                         <span>{{ . }}</span>

     

       78
        
                       </div>

     

       79
        
                     {{end }}

···

       73
        
                   {{ with .Repo.RepoStats }}

     

       74
        
                     {{ with .Language }}

     

       75
        
                       <div class="flex gap-2 items-center text-xs font-mono text-gray-400 ">

     

       76
       +
                         {{ template "repo/fragments/colorBall" (dict "color" (langColor .)) }}

     

       77
        
                         <span>{{ . }}</span>

     

       78
        
                       </div>

     

       79
        
                     {{end }}

+1 -1

appview/issues/router.go

···

       14
        
       		r.With(middleware.Paginate).Get("/", i.RepoIssues)

     

       15
        
       

     

       16
        
       		r.Route("/{issue}", func(r chi.Router) {

     

       17
       -
       			r.Use(mw.ResolveIssue())

     

       18
        
       			r.Get("/", i.RepoSingleIssue)

     

       19
        
       

     

       20
        
       			// authenticated routes

···

       14
        
       		r.With(middleware.Paginate).Get("/", i.RepoIssues)

     

       15
        
       

     

       16
        
       		r.Route("/{issue}", func(r chi.Router) {

     

       17
       +
       			r.Use(mw.ResolveIssue)

     

       18
        
       			r.Get("/", i.RepoSingleIssue)

     

       19
        
       

     

       20
        
       			// authenticated routes

+1 -1

appview/pages/templates/repo/settings/pipelines.html

···

       109
        
         hx-swap="none"

     

       110
        
         class="flex flex-col gap-2"

     

       111
        
       >

     

       112
       -
         <p class="uppercase p-0">ADD SECRET</p>

     

       113
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Secrets are available as environment variables in the workflow.</p>

     

       114
        
         <input

     

       115
        
           type="text"

···

       109
        
         hx-swap="none"

     

       110
        
         class="flex flex-col gap-2"

     

       111
        
       >

     

       112
       +
         <p class="uppercase p-0 font-bold">ADD SECRET</p>

     

       113
        
         <p class="text-sm text-gray-500 dark:text-gray-400">Secrets are available as environment variables in the workflow.</p>

     

       114
        
         <input

     

       115
        
           type="text"

appview/pages/templates/labels/fragments/labelDef.html

···

       1
       +
       {{ define "labels/fragments/labelDef" }}

     

       2
       +
         <span class="flex items-center gap-2 font-normal normal-case">

     

       3
       +
           {{ template "repo/fragments/colorBall" (dict "color" .GetColor) }}

     

       4
       +
           {{ .Name }}

     

       5
       +
         </span>

     

       6
       +
       {{ end }}

+6 -8

appview/pages/templates/layouts/repobase.html

···

       41
        
             {{ template "repo/fragments/repoDescription" . }}

     

       42
        
           </section>

     

       43
        
       

     

       44
       -
           <section

     

       45
       -
               class="w-full flex flex-col"

     

       46
       -
           >

     

       47
        
               <nav class="w-full pl-4 overflow-auto">

     

       48
        
                   <div class="flex z-60">

     

       49
        
                       {{ $activeTabStyles := "-mb-px bg-white dark:bg-gray-800" }}

     
···

       80
        
                       {{ end }}

     

       81
        
                   </div>

     

       82
        
               </nav>

     

       83
       -
               <section

     

       84
       -
                   class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white"

     

       85
       -
               >

     

       86
        
                   {{ block "repoContent" . }}{{ end }}

     

       87
       -
               </section>

     

       88
       -
               {{ block "repoAfter" . }}{{ end }}

     

       0
        
       
     

       89
        
           </section>

     

       90
        
       {{ end }}

···

       41
        
             {{ template "repo/fragments/repoDescription" . }}

     

       42
        
           </section>

     

       43
        
       

     

       44
       +
           <section class="w-full flex flex-col" >

     

       0
        
       
     

       0
        
       
     

       45
        
               <nav class="w-full pl-4 overflow-auto">

     

       46
        
                   <div class="flex z-60">

     

       47
        
                       {{ $activeTabStyles := "-mb-px bg-white dark:bg-gray-800" }}

     
···

       78
        
                       {{ end }}

     

       79
        
                   </div>

     

       80
        
               </nav>

     

       81
       +
               {{ block "repoContentLayout" . }}

     

       82
       +
                 <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white">

     

       0
        
       
     

       83
        
                   {{ block "repoContent" . }}{{ end }}

     

       84
       +
                 </section>

     

       85
       +
                 {{ block "repoAfter" . }}{{ end }}

     

       86
       +
               {{ end }}

     

       87
        
           </section>

     

       88
        
       {{ end }}

+4 -4

appview/pages/templates/repo/issues/fragments/commentList.html

···

       3
        
           {{ range $item := .CommentList }}

     

       4
        
             {{ template "commentListing" (list $ .) }}

     

       5
        
           {{ end }}

     

       6
       -
         <div>

     

       7
        
       {{ end }}

     

       8
        
       

     

       9
        
       {{ define "commentListing" }}

     
···

       16
        
                 "Issue" $root.Issue

     

       17
        
                 "Comment" $comment.Self) }}

     

       18
        
       

     

       19
       -
         <div class="rounded border border-gray-300 dark:border-gray-700 w-full overflow-hidden shadow-sm">

     

       20
        
           {{ template "topLevelComment" $params }}

     

       21
        
       

     

       22
       -
           <div class="relative ml-4 border-l border-gray-300 dark:border-gray-700">

     

       23
        
             {{ range $index, $reply := $comment.Replies }}

     

       24
        
               <div class="relative ">

     

       25
        
                 <!-- Horizontal connector -->

     

       26
       -
                 <div class="absolute left-0 top-6 w-4 h-px bg-gray-300 dark:bg-gray-700"></div>

     

       27
        
       

     

       28
        
                 <div class="pl-2">

     

       29
        
                   {{

···

       3
        
           {{ range $item := .CommentList }}

     

       4
        
             {{ template "commentListing" (list $ .) }}

     

       5
        
           {{ end }}

     

       6
       +
         </div>

     

       7
        
       {{ end }}

     

       8
        
       

     

       9
        
       {{ define "commentListing" }}

     
···

       16
        
                 "Issue" $root.Issue

     

       17
        
                 "Comment" $comment.Self) }}

     

       18
        
       

     

       19
       +
         <div class="rounded border border-gray-200 dark:border-gray-700 w-full overflow-hidden shadow-sm bg-gray-50 dark:bg-gray-800/50">

     

       20
        
           {{ template "topLevelComment" $params }}

     

       21
        
       

     

       22
       +
           <div class="relative ml-4 border-l-2 border-gray-200 dark:border-gray-700">

     

       23
        
             {{ range $index, $reply := $comment.Replies }}

     

       24
        
               <div class="relative ">

     

       25
        
                 <!-- Horizontal connector -->

     

       26
       +
                 <div class="absolute left-0 top-6 w-4 h-1 bg-gray-200 dark:bg-gray-700"></div>

     

       27
        
       

     

       28
        
                 <div class="pl-2">

     

       29
        
                   {{

+21 -2

appview/pages/templates/labels/fragments/label.html

···

       1
        
       {{ define "labels/fragments/label" }}

     

       2
        
         {{ $d := .def }}

     

       3
        
         {{ $v := .val }}

     

       0
        
       
     

       4
        
         <span class="flex items-center gap-2 font-normal normal-case rounded py-1 px-2 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-sm">

     

       5
        
           {{ template "repo/fragments/colorBall" (dict "color" $d.GetColor) }}

     

       6
       -
           {{ $d.Name }}{{ if not $d.ValueType.IsNull }}/{{ template "labelVal" (dict "def" $d "val" $v) }}{{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
         </span>

     

       8
        
       {{ end }}

     

       9
        
       

     
···

       13
        
         {{ $v := .val }}

     

       14
        
       

     

       15
        
         {{ if $d.ValueType.IsDidFormat }}

     

       16
       -
           {{ resolve $v }}

     

       17
        
         {{ else }}

     

       18
        
           {{ $v }}

     

       19
        
         {{ end }}

···

       1
        
       {{ define "labels/fragments/label" }}

     

       2
        
         {{ $d := .def }}

     

       3
        
         {{ $v := .val }}

     

       4
       +
         {{ $withPrefix := .withPrefix }}

     

       5
        
         <span class="flex items-center gap-2 font-normal normal-case rounded py-1 px-2 border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-sm">

     

       6
        
           {{ template "repo/fragments/colorBall" (dict "color" $d.GetColor) }}

     

       7
       +
       

     

       8
       +
           {{ $lhs := printf "%s" $d.Name }}

     

       9
       +
           {{ $rhs := "" }}

     

       10
       +
       

     

       11
       +
           {{ if not $d.ValueType.IsNull }}

     

       12
       +
             {{ if $d.ValueType.IsDidFormat }}

     

       13
       +
               {{ $v = resolve $v }}

     

       14
       +
             {{ end }}

     

       15
       +
       

     

       16
       +
             {{ if not $withPrefix }}

     

       17
       +
               {{ $lhs = "" }}

     

       18
       +
             {{ else }}

     

       19
       +
               {{ $lhs = printf "%s/" $d.Name }}

     

       20
       +
             {{ end }}

     

       21
       +
       

     

       22
       +
             {{ $rhs = printf "%s" $v }}

     

       23
       +
           {{ end }}

     

       24
       +
       

     

       25
       +
           {{ printf "%s%s" $lhs $rhs }}

     

       26
        
         </span>

     

       27
        
       {{ end }}

     

       28
        
       

     
···

       32
        
         {{ $v := .val }}

     

       33
        
       

     

       34
        
         {{ if $d.ValueType.IsDidFormat }}

     

       35
       +
             {{ resolve $v }}

     

       36
        
         {{ else }}

     

       37
        
           {{ $v }}

     

       38
        
         {{ end }}

-127

appview/pages/templates/repo/fragments/addLabelModal.html

···

       1
       -
       {{ define "repo/fragments/addLabelModal" }}

     

       2
       -
         {{ $root := .root }}

     

       3
       -
         {{ $subject := .subject }}

     

       4
       -
         {{ $state := .state }}

     

       5
       -
         {{ with $root }}

     

       6
       -
           <form

     

       7
       -
             hx-put="/{{ .RepoInfo.FullName }}/labels/perform"

     

       8
       -
             hx-on::after-request="this.reset()"

     

       9
       -
             hx-indicator="#spinner"

     

       10
       -
             hx-swap="none"

     

       11
       -
             class="flex flex-col gap-4"

     

       12
       -
           >

     

       13
       -
             <p class="text-gray-500 dark:text-gray-400">Add, remove or update labels.</p>

     

       14
       -
       

     

       15
       -
             <input class="hidden" name="repo" value="{{ .RepoInfo.RepoAt.String }}">

     

       16
       -
             <input class="hidden" name="subject" value="{{ $subject }}">

     

       17
       -
       

     

       18
       -
             <div class="flex flex-col gap-2">

     

       19
       -
               {{ $id := 0 }}

     

       20
       -
               {{ range $k, $valset := $state.Inner }}

     

       21
       -
                 {{ $d := index $root.LabelDefs $k }}

     

       22
       -
                 {{ range $v, $s := $valset }}

     

       23
       -
                   {{ template "labelCheckbox" (dict "def" $d "key" $k "val" $v "id" $id "isChecked" true) }}

     

       24
       -
                   {{ $id = add $id 1 }}

     

       25
       -
                 {{ end }}

     

       26
       -
               {{ end }}

     

       27
       -
       

     

       28
       -
               {{ range $k, $d := $root.LabelDefs }}

     

       29
       -
                 {{ if not ($state.ContainsLabel $k) }}

     

       30
       -
                   {{ template "labelCheckbox" (dict "def" $d "key" $k "val" "" "id" $id "isChecked" false) }}

     

       31
       -
                   {{ $id = add $id 1 }}

     

       32
       -
                 {{ end }}

     

       33
       -
               {{ else }}

     

       34
       -
                 <span>

     

       35
       -
                   No labels defined yet. You can define custom labels in <a class="underline" href="/{{ .RepoInfo.FullName }}/settings">settings</a>.

     

       36
       -
                 </span>

     

       37
       -
               {{ end }}

     

       38
       -
             </div>

     

       39
       -
       

     

       40
       -
             <div class="flex gap-2 pt-2">

     

       41
       -
               <button

     

       42
       -
                 type="button"

     

       43
       -
                 popovertarget="add-label-modal"

     

       44
       -
                 popovertargetaction="hide"

     

       45
       -
                 class="btn w-1/2 flex items-center gap-2 text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"

     

       46
       -
                 >

     

       47
       -
                 {{ i "x" "size-4" }} cancel

     

       48
       -
               </button>

     

       49
       -
               <button type="submit" class="btn w-1/2 flex items-center">

     

       50
       -
                 <span class="inline-flex gap-2 items-center">{{ i "check" "size-4" }} save</span>

     

       51
       -
                 <span id="spinner" class="group">

     

       52
       -
                   {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       53
       -
                 </span>

     

       54
       -
               </button>

     

       55
       -
             </div>

     

       56
       -
             <div id="add-label-error" class="text-red-500 dark:text-red-400"></div>

     

       57
       -
           </form>

     

       58
       -
         {{ end }}

     

       59
       -
       {{ end }}

     

       60
       -
       

     

       61
       -
       {{ define "labelCheckbox" }}

     

       62
       -
         {{ $key := .key }}

     

       63
       -
         {{ $val := .val }}

     

       64
       -
         {{ $def := .def }}

     

       65
       -
         {{ $id := .id }}

     

       66
       -
         {{ $isChecked := .isChecked }}

     

       67
       -
         <div class="grid grid-cols-[auto_1fr_50%] gap-2 items-center cursor-pointer">

     

       68
       -
           <input type="checkbox" id="op-{{$id}}" name="op-{{$id}}" value="add" {{if $isChecked}}checked{{end}} class="peer">

     

       69
       -
           <label for="op-{{$id}}" class="flex items-center gap-2 text-base">{{ template "labels/fragments/labelDef" $def }}</label>

     

       70
       -
           <div class="w-full hidden peer-checked:block">{{ template "valueTypeInput" (dict "valueType" $def.ValueType "value" $val "key" $key) }}</div>

     

       71
       -
           <input type="hidden" name="operand-key" value="{{ $key }}">

     

       72
       -
         </div>

     

       73
       -
       {{ end }}

     

       74
       -
       

     

       75
       -
       {{ define "valueTypeInput" }}

     

       76
       -
         {{ $valueType := .valueType }}

     

       77
       -
         {{ $value := .value }}

     

       78
       -
         {{ $key := .key }}

     

       79
       -
       

     

       80
       -
         {{ if $valueType.IsEnumType }}

     

       81
       -
           {{ template "enumTypeInput" $ }}

     

       82
       -
         {{ else if $valueType.IsBool }}

     

       83
       -
           {{ template "boolTypeInput" $ }}

     

       84
       -
         {{ else if $valueType.IsInt }}

     

       85
       -
           {{ template "intTypeInput" $ }}

     

       86
       -
         {{ else if $valueType.IsString }}

     

       87
       -
           {{ template "stringTypeInput" $ }}

     

       88
       -
         {{ else if $valueType.IsNull }}

     

       89
       -
           {{ template "nullTypeInput" $ }}

     

       90
       -
         {{ end }}

     

       91
       -
       {{ end }}

     

       92
       -
       

     

       93
       -
       {{ define "enumTypeInput" }}

     

       94
       -
         {{ $valueType := .valueType }}

     

       95
       -
         {{ $value := .value }}

     

       96
       -
         <select name="operand-val" class="w-full p-1 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       97
       -
           {{ range $valueType.Enum }}

     

       98
       -
             <option value="{{.}}" {{ if eq $value . }} selected {{ end }}>{{.}}</option>

     

       99
       -
           {{ end }}

     

       100
       -
         </select>

     

       101
       -
       {{ end }}

     

       102
       -
       

     

       103
       -
       {{ define "boolTypeInput" }}

     

       104
       -
         {{ $value := .value }}

     

       105
       -
         <select name="operand-val" class="w-full p-1 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       106
       -
           <option value="true" {{ if $value }} selected {{ end }}>true</option>

     

       107
       -
           <option value="false" {{ if not $value }} selected {{ end }}>false</option>

     

       108
       -
         </select>

     

       109
       -
       {{ end }}

     

       110
       -
       

     

       111
       -
       {{ define "intTypeInput" }}

     

       112
       -
         {{ $value := .value }}

     

       113
       -
         <input class="p-1 w-full" type="number" name="operand-val" value="{{$value}}" max="100">

     

       114
       -
       {{ end }}

     

       115
       -
       

     

       116
       -
       {{ define "stringTypeInput" }}

     

       117
       -
         {{ $valueType := .valueType }}

     

       118
       -
         {{ $value := .value }}

     

       119
       -
         {{ if $valueType.IsDidFormat }}

     

       120
       -
           {{ $value = resolve .value }}

     

       121
       -
         {{ end }}

     

       122
       -
         <input class="p-1 w-full" type="text" name="operand-val" value="{{$value}}">

     

       123
       -
       {{ end }}

     

       124
       -
       

     

       125
       -
       {{ define "nullTypeInput" }}

     

       126
       -
         <input class="p-1" type="hidden" name="operand-val" value="null">

     

       127
       -
       {{ end }}

+208

appview/pages/templates/repo/fragments/editLabelPanel.html

···

       1
       +
       {{ define "repo/fragments/editLabelPanel" }}

     

       2
       +
         <form

     

       3
       +
           id="edit-label-panel"

     

       4
       +
           hx-put="/{{ .RepoInfo.FullName }}/labels/perform"

     

       5
       +
           hx-indicator="#spinner"

     

       6
       +
           hx-disabled-elt="#save-btn,#cancel-btn"

     

       7
       +
           hx-swap="none"

     

       8
       +
           class="flex flex-col gap-6"

     

       9
       +
           >

     

       10
       +
           <input type="hidden" name="repo" value="{{ .RepoInfo.RepoAt }}">

     

       11
       +
           <input type="hidden" name="subject" value="{{ .Subject }}">

     

       12
       +
           {{ template "editBasicLabels" . }}

     

       13
       +
           {{ template "editKvLabels" . }}

     

       14
       +
           {{ template "editLabelPanelActions" . }}

     

       15
       +
           <div id="add-label-error" class="text-red-500 dark:text-red-400"></div>

     

       16
       +
         </form>

     

       17
       +
       {{ end }}

     

       18
       +
       

     

       19
       +
       {{ define "editBasicLabels" }}

     

       20
       +
         {{ $defs := .Defs }}

     

       21
       +
         {{ $subject := .Subject }}

     

       22
       +
         {{ $state := .State }}

     

       23
       +
         {{ $labelStyle := "flex items-center gap-2 rounded py-1 px-2 border border-gray-200 dark:border-gray-700 text-sm bg-white dark:bg-gray-800 text-black dark:text-white" }}

     

       24
       +
         <div>

     

       25
       +
           {{ template "repo/fragments/labelSectionHeaderText" "Labels" }}

     

       26
       +
       

     

       27
       +
           <div class="flex gap-1 items-center flex-wrap">

     

       28
       +
             {{ range $k, $d := $defs }}

     

       29
       +
               {{ $isChecked := $state.ContainsLabel $k }}

     

       30
       +
               {{ if $d.ValueType.IsNull }}

     

       31
       +
                 {{ $fieldName := $d.AtUri }}

     

       32
       +
                 <label class="{{$labelStyle}}">

     

       33
       +
                   <input type="checkbox" id="{{ $fieldName }}" name="{{ $fieldName }}" value="null" {{if $isChecked}}checked{{end}}>

     

       34
       +
                   {{ template "labels/fragments/labelDef" $d }}

     

       35
       +
                 </label>

     

       36
       +
               {{ end }}

     

       37
       +
             {{ else }}

     

       38
       +
               <p class="text-gray-500 dark:text-gray-400 text-sm py-1">

     

       39
       +
                 No labels defined yet. You can choose default labels or define custom

     

       40
       +
                 labels in <a class="underline" href="/{{ $.RepoInfo.FullName }}/settings">settings</a>.

     

       41
       +
               </p>

     

       42
       +
             {{ end }}

     

       43
       +
           </div>

     

       44
       +
         </div>

     

       45
       +
       {{ end }}

     

       46
       +
       

     

       47
       +
       {{ define "editKvLabels" }}

     

       48
       +
         {{ $defs := .Defs }}

     

       49
       +
         {{ $subject := .Subject }}

     

       50
       +
         {{ $state := .State }}

     

       51
       +
         {{ $labelStyle := "font-normal normal-case flex items-center gap-2 p-0" }}

     

       52
       +
       

     

       53
       +
         {{ range $k, $d := $defs }}

     

       54
       +
           {{ if (not $d.ValueType.IsNull) }}

     

       55
       +
             {{ $fieldName := $d.AtUri }}

     

       56
       +
             {{ $valset := $state.GetValSet $k }}

     

       57
       +
             <div id="label-{{$d.Id}}" class="flex flex-col gap-1">

     

       58
       +
               {{ template "repo/fragments/labelSectionHeaderText" $d.Name }}

     

       59
       +
                 {{ if (and $d.Multiple $d.ValueType.IsEnum) }}

     

       60
       +
                   <!-- checkbox -->

     

       61
       +
                   {{ range $variant := $d.ValueType.Enum }}

     

       62
       +
                     <label class="{{$labelStyle}}">

     

       63
       +
                       <input type="checkbox" name="{{ $fieldName }}" value="{{$variant}}" {{if $state.ContainsLabelAndVal $k $variant}}checked{{end}}>

     

       64
       +
                       {{ $variant }}

     

       65
       +
                     </label>

     

       66
       +
                   {{ end }}

     

       67
       +
                 {{ else if $d.Multiple }}

     

       68
       +
                   <!-- dynamically growing input fields -->

     

       69
       +
                   {{ range $v, $s := $valset }}

     

       70
       +
                     {{ template "multipleInputField" (dict "def" $d "value" $v "key" $k) }}

     

       71
       +
                   {{ else }}

     

       72
       +
                     {{ template "multipleInputField" (dict "def" $d "value" "" "key" $k) }}

     

       73
       +
                   {{ end }}

     

       74
       +
                   {{ template "addFieldButton" $d }}

     

       75
       +
                 {{ else if $d.ValueType.IsEnum }}

     

       76
       +
                   <!-- radio buttons -->

     

       77
       +
                   {{ $isUsed := $state.ContainsLabel $k }}

     

       78
       +
                   {{ range $variant := $d.ValueType.Enum }}

     

       79
       +
                     <label class="{{$labelStyle}}">

     

       80
       +
                       <input type="radio" name="{{ $fieldName }}" value="{{$variant}}" {{if $state.ContainsLabelAndVal $k $variant}}checked{{end}}>

     

       81
       +
                       {{ $variant }}

     

       82
       +
                     </label>

     

       83
       +
                   {{ end }}

     

       84
       +
                   <label class="{{$labelStyle}}">

     

       85
       +
                     <input type="radio" name="{{ $fieldName }}" value="" {{ if not $isUsed }}checked{{ end }}>

     

       86
       +
                     None

     

       87
       +
                   </label>

     

       88
       +
                 {{ else }}

     

       89
       +
                   <!-- single input field based on value type -->

     

       90
       +
                   {{ range $v, $s := $valset }}

     

       91
       +
                     {{ template "valueTypeInput" (dict "def" $d "value" $v "key" $k) }}

     

       92
       +
                   {{ else }}

     

       93
       +
                     {{ template "valueTypeInput" (dict "def" $d "value" "" "key" $k) }}

     

       94
       +
                   {{ end }}

     

       95
       +
                 {{ end }}

     

       96
       +
             </div>

     

       97
       +
           {{ end }}

     

       98
       +
         {{ end }}

     

       99
       +
       {{ end }}

     

       100
       +
       

     

       101
       +
       {{ define "multipleInputField" }}

     

       102
       +
         <div class="flex gap-1 items-stretch">

     

       103
       +
           {{ template "valueTypeInput" . }}

     

       104
       +
           {{ template "removeFieldButton" }}

     

       105
       +
         </div>

     

       106
       +
       {{ end }}

     

       107
       +
       

     

       108
       +
       {{ define "addFieldButton" }}

     

       109
       +
         <div style="display:none" id="tpl-{{ .Id }}">

     

       110
       +
           {{ template "multipleInputField" (dict "def" . "value" "" "key" .AtUri.String) }}

     

       111
       +
         </div>

     

       112
       +
         <button type="button" onClick="this.insertAdjacentHTML('beforebegin', document.getElementById('tpl-{{ .Id }}').innerHTML)" class="w-full btn flex items-center gap-2">

     

       113
       +
           {{ i "plus" "size-4" }} add

     

       114
       +
         </button>

     

       115
       +
       {{ end }}

     

       116
       +
       

     

       117
       +
       {{ define "removeFieldButton" }}

     

       118
       +
         <button type="button" onClick="this.parentElement.remove()" class="btn flex items-center gap-2 text-red-400 dark:text-red-500">

     

       119
       +
           {{ i "trash-2" "size-4" }}

     

       120
       +
         </button>

     

       121
       +
       {{ end }}

     

       122
       +
       

     

       123
       +
       {{ define "valueTypeInput" }}

     

       124
       +
         {{ $def := .def }}

     

       125
       +
         {{ $valueType := $def.ValueType }}

     

       126
       +
         {{ $value := .value }}

     

       127
       +
         {{ $key := .key }}

     

       128
       +
       

     

       129
       +
         {{ if $valueType.IsBool }}

     

       130
       +
           {{ template "boolTypeInput" $ }}

     

       131
       +
         {{ else if $valueType.IsInt }}

     

       132
       +
           {{ template "intTypeInput" $ }}

     

       133
       +
         {{ else if $valueType.IsString }}

     

       134
       +
           {{ template "stringTypeInput" $ }}

     

       135
       +
         {{ else if $valueType.IsNull }}

     

       136
       +
           {{ template "nullTypeInput" $ }}

     

       137
       +
         {{ end }}

     

       138
       +
       {{ end }}

     

       139
       +
       

     

       140
       +
       {{ define "boolTypeInput" }}

     

       141
       +
         {{ $def := .def }}

     

       142
       +
         {{ $fieldName := $def.AtUri }}

     

       143
       +
         {{ $value := .value }}

     

       144
       +
         {{ $labelStyle = "font-normal normal-case flex items-center gap-2" }}

     

       145
       +
         <div class="flex flex-col gap-1">

     

       146
       +
           <label class="{{$labelStyle}}">

     

       147
       +
             <input type="radio" name="{{ $fieldName }}" value="true" {{ if not $value }}checked{{ end }}>

     

       148
       +
             None

     

       149
       +
           </label>

     

       150
       +
           <label class="{{$labelStyle}}">

     

       151
       +
             <input type="radio" name="{{ $fieldName }}" value="true" {{ if not $value }}checked{{ end }}>

     

       152
       +
             None

     

       153
       +
           </label>

     

       154
       +
           <label class="{{$labelStyle}}">

     

       155
       +
             <input type="radio" name="{{ $fieldName }}" value="true" {{ if not $value }}checked{{ end }}>

     

       156
       +
             None

     

       157
       +
           </label>

     

       158
       +
         </div>

     

       159
       +
       {{ end }}

     

       160
       +
       

     

       161
       +
       {{ define "intTypeInput" }}

     

       162
       +
         {{ $def := .def }}

     

       163
       +
         {{ $fieldName := $def.AtUri }}

     

       164
       +
         {{ $value := .value }}

     

       165
       +
         <input class="p-1 w-full" type="number" name="{{$fieldName}}" value="{{$value}}">

     

       166
       +
       {{ end }}

     

       167
       +
       

     

       168
       +
       {{ define "stringTypeInput" }}

     

       169
       +
         {{ $def := .def }}

     

       170
       +
         {{ $fieldName := $def.AtUri }}

     

       171
       +
         {{ $valueType := $def.ValueType }}

     

       172
       +
         {{ $value := .value }}

     

       173
       +
         {{ if $valueType.IsDidFormat }}

     

       174
       +
           {{ $value = trimPrefix (resolve .value) "@" }}

     

       175
       +
         {{ end }}

     

       176
       +
         <input class="p-1 w-full" type="text" name="{{$fieldName}}" value="{{$value}}">

     

       177
       +
       {{ end }}

     

       178
       +
       

     

       179
       +
       {{ define "nullTypeInput" }}

     

       180
       +
         {{ $def := .def }}

     

       181
       +
         {{ $fieldName := $def.AtUri }}

     

       182
       +
         <input class="p-1" type="hidden" name="{{$fieldName}}" value="null">

     

       183
       +
       {{ end }}

     

       184
       +
       

     

       185
       +
       {{ define "editLabelPanelActions" }}

     

       186
       +
         <div class="flex gap-2 pt-2">

     

       187
       +
           <button

     

       188
       +
             id="cancel-btn"

     

       189
       +
             type="button"

     

       190
       +
             hx-get="/{{ .RepoInfo.FullName }}/label"

     

       191
       +
             hx-vals='{"subject": "{{.Subject}}"}'

     

       192
       +
             hx-swap="outerHTML"

     

       193
       +
             hx-target="#edit-label-panel"

     

       194
       +
             class="btn w-1/2 flex items-center gap-2 text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 group">

     

       195
       +
             {{ i "x" "size-4" }} cancel

     

       196
       +
           </button>

     

       197
       +
       

     

       198
       +
           <button

     

       199
       +
             id="save-btn"

     

       200
       +
             type="submit"

     

       201
       +
             class="btn w-1/2 flex items-center">

     

       202
       +
             <span class="inline-flex gap-2 items-center">{{ i "check" "size-4" }} save</span>

     

       203
       +
             <span id="spinner" class="group">

     

       204
       +
               {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       205
       +
             </span>

     

       206
       +
           </button>

     

       207
       +
         </div>

     

       208
       +
       {{ end }}

+16

appview/pages/templates/repo/fragments/labelSectionHeader.html

···

       1
       +
       {{ define "repo/fragments/labelSectionHeader" }}

     

       2
       +
       

     

       3
       +
         <div class="flex justify-between items-center gap-2">

     

       4
       +
           {{ template "repo/fragments/labelSectionHeaderText" .Name }}

     

       5
       +
           {{ if (or .RepoInfo.Roles.IsOwner .RepoInfo.Roles.IsCollaborator) }}

     

       6
       +
             <a

     

       7
       +
               class="text-gray-500 dark:text-gray-400 flex gap-1 items-center group"

     

       8
       +
               hx-get="/{{ .RepoInfo.FullName }}/label/edit"

     

       9
       +
               hx-vals='{"subject": "{{.Subject}}"}'

     

       10
       +
               hx-swap="outerHTML"

     

       11
       +
               hx-target="#label-panel">

     

       12
       +
               {{ i "pencil" "size-3" }}

     

       13
       +
             </a>

     

       14
       +
           {{ end }}

     

       15
       +
         </div>

     

       16
       +
       {{ end }}

appview/pages/templates/repo/fragments/labelSectionHeaderText.html

···

       1
       +
       {{ define "repo/fragments/labelSectionHeaderText" }}

     

       2
       +
         <span class="text-sm py-1 font-bold text-gray-500 dark:text-gray-400 capitalize">{{ . }}</span>

     

       3
       +
       {{ end }}

+138 -86

appview/pages/templates/repo/settings/fragments/addLabelDefModal.html

···

       1
        
       {{ define "repo/settings/fragments/addLabelDefModal" }}

     

       2
       -
       <form

     

       3
       -
         hx-put="/{{ $.RepoInfo.FullName }}/settings/label"

     

       4
       -
         hx-indicator="#spinner"

     

       5
       -
         hx-swap="none"

     

       6
       -
         hx-on::after-request="if(event.detail.successful) this.reset()"

     

       7
       -
         class="flex flex-col gap-4"

     

       8
       -
       >

     

       9
       -
         <p class="text-gray-500 dark:text-gray-400">Labels can have a name and a value. Set the value type to "none" to create a simple label.</p>

     

       10
        
       

     

       11
       -
         <div class="w-full">

     

       12
       -
           <label for="name">Name</label>

     

       13
       -
           <input class="w-full" type="text" id="label-name" name="name" required placeholder="improvement"/>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
         </div>

     

       15
        
       

     

       16
       -
          <!-- Value Type -->

     

       17
       -
         <div class="w-full">

     

       18
       -
           <label for="valueType">Value Type</label>

     

       19
       -
           <select id="value-type" name="valueType" class="w-full p-3 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       20
       -
             <option value="null" selected>None</option>

     

       21
       -
             <option value="string">String</option>

     

       22
       -
             <option value="integer">Integer</option>

     

       23
       -
             <option value="boolean">Boolean</option>

     

       24
       -
           </select>

     

       25
       -
           <details id="constrain-values" class="group hidden">

     

       26
       -
             <summary class="list-none cursor-pointer flex items-center gap-2 py-2">

     

       27
       -
               <span class="group-open:hidden inline text-gray-500 dark:text-gray-400">{{ i "square-plus" "w-4 h-4" }}</span>

     

       28
       -
               <span class="hidden group-open:inline text-gray-500 dark:text-gray-400">{{ i "square-minus" "w-4 h-4" }}</span>

     

       29
       -
               <span>Constrain values</span>

     

       30
       -
             </summary>

     

       31
       -
             <label for="enumValues">Permitted values</label>

     

       32
       -
             <input type="text" id="enumValues" name="enumValues" placeholder="value1, value2, value3" class="w-full"/>

     

       33
       -
             <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">Enter comma-separated list of permitted values.</p>

     

       34
       -
       

     

       35
       -
             <label for="valueFormat">String format</label>

     

       36
       -
             <select id="valueFormat" name="valueFormat" class="w-full p-3 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       37
       -
               <option value="any" selected>Any</option>

     

       38
       -
               <option value="did">DID</option>

     

       39
       -
             </select>

     

       40
       -
             <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">Choose a string format.</p>

     

       41
       -
           </details>

     

       42
        
         </div>

     

       43
        
       

     

       44
       -
         <!-- Scope -->

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
         <div class="w-full">

     

       46
       -
           <label for="scope">Scope</label>

     

       47
       -
           <select id="scope" name="scope" class="w-full p-3 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       48
       -
             <option value="sh.tangled.repo.issue">Issues</option>

     

       49
       -
             <option value="sh.tangled.repo.pull">Pull Requests</option>

     

       50
       -
           </select>

     

       51
        
         </div>

     

       0
        
       
     

       52
        
       

     

       53
       -
         <!-- Color -->

     

       54
        
         <div class="w-full">

     

       55
        
           <label for="color">Color</label>

     

       56
        
           <div class="grid grid-cols-4 grid-rows-2 place-items-center">

     
···

       63
        
             {{ end }}

     

       64
        
           </div>

     

       65
        
         </div>

     

       0
        
       
     

       66
        
       

     

       67
       -
         <!-- Multiple -->

     

       68
       -
         <div class="w-full flex flex-wrap gap-2">

     

       69
       -
           <input type="checkbox" id="multiple" name="multiple" value="true" />

     

       70
       -
           <span>

     

       71
       -
             Allow multiple values

     

       72
       -
           </span>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       73
        
         </div>

     

       74
        
       

     

       75
       -
         <div class="flex gap-2 pt-2">

     

       76
       -
           <button

     

       77
       -
             type="button"

     

       78
       -
             popovertarget="add-labeldef-modal"

     

       79
       -
             popovertargetaction="hide"

     

       80
       -
             class="btn w-1/2 flex items-center gap-2 text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"

     

       81
       -
             >

     

       82
       -
             {{ i "x" "size-4" }} cancel

     

       83
       -
           </button>

     

       84
       -
           <button type="submit" class="btn w-1/2 flex items-center">

     

       85
       -
             <span class="inline-flex gap-2 items-center">{{ i "plus" "size-4" }} add</span>

     

       86
       -
             <span id="spinner" class="group">

     

       87
       -
               {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       88
       -
             </span>

     

       89
       -
           </button>

     

       90
        
         </div>

     

       91
       -
         <div id="add-label-error" class="text-red-500 dark:text-red-400"></div>

     

       92
       -
       </form>

     

       93
       -
       

     

       94
       -
       <script>

     

       95
       -
         document.getElementById('value-type').addEventListener('change', function() {

     

       96
       -
           const constrainValues = document.getElementById('constrain-values');

     

       97
       -
           const selectedValue = this.value;

     

       98
       -
       

     

       99
       -
           if (selectedValue === 'string') {

     

       100
       -
             constrainValues.classList.remove('hidden');

     

       101
       -
           } else {

     

       102
       -
             constrainValues.classList.add('hidden');

     

       103
       -
             constrainValues.removeAttribute('open');

     

       104
       -
             document.getElementById('enumValues').value = '';

     

       105
       -
           }

     

       106
       -
         });

     

       107
       -
       

     

       108
       -
         function toggleDarkMode() {

     

       109
       -
           document.documentElement.classList.toggle('dark');

     

       110
       -
         }

     

       111
       -
       </script>

     

       112
        
       {{ end }}

     

       113
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
        
       {{ define "repo/settings/fragments/addLabelDefModal" }}

     

       2
       +
       <div class="grid grid-cols-2">

     

       3
       +
         <input type="radio" name="tab" id="basic-tab" value="basic" class="hidden peer/basic" checked>

     

       4
       +
         <input type="radio" name="tab" id="kv-tab" value="kv" class="hidden peer/kv">

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       5
        
       

     

       6
       +
         <!-- Labels as direct siblings -->

     

       7
       +
         {{ $base := "py-2 text-sm font-normal normal-case block hover:no-underline text-center cursor-pointer bg-gray-100 dark:bg-gray-800 shadow-inner border border-gray-200 dark:border-gray-700" }}

     

       8
       +
         <label for="basic-tab" class="{{$base}} peer-checked/basic:bg-white peer-checked/basic:dark:bg-gray-700 peer-checked/basic:shadow-sm rounded-l">

     

       9
       +
           Basic Labels

     

       10
       +
         </label>

     

       11
       +
         <label for="kv-tab" class="{{$base}} peer-checked/kv:bg-white peer-checked/kv:dark:bg-gray-700 peer-checked/kv:shadow-sm rounded-r">

     

       12
       +
           Key-value Labels

     

       13
       +
         </label>

     

       14
       +
       

     

       15
       +
         <!-- Basic Labels Content - direct sibling -->

     

       16
       +
         <div class="mt-4 hidden peer-checked/basic:block col-span-full">

     

       17
       +
           {{ template "basicLabelDef" . }}

     

       18
        
         </div>

     

       19
        
       

     

       20
       +
         <!-- Key-value Labels Content - direct sibling -->

     

       21
       +
         <div class="mt-4 hidden peer-checked/kv:block col-span-full">

     

       22
       +
           {{ template "kvLabelDef" . }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       23
        
         </div>

     

       24
        
       

     

       25
       +
         <div id="add-label-error" class="text-red-500 dark:text-red-400 col-span-full"></div>

     

       26
       +
       </div>

     

       27
       +
       {{ end }}

     

       28
       +
       

     

       29
       +
       {{ define "basicLabelDef" }}

     

       30
       +
         <form

     

       31
       +
           hx-put="/{{ $.RepoInfo.FullName }}/settings/label"

     

       32
       +
           hx-indicator="#spinner"

     

       33
       +
           hx-swap="none"

     

       34
       +
           hx-on::after-request="if(event.detail.successful) this.reset()"

     

       35
       +
           class="flex flex-col space-y-4">

     

       36
       +
       

     

       37
       +
           <p class="text-gray-500 dark:text-gray-400">These labels can have a name and a color.</p>

     

       38
       +
       

     

       39
       +
           {{ template "nameInput" . }}

     

       40
       +
           {{ template "scopeInput" . }}

     

       41
       +
           {{ template "colorInput" . }}

     

       42
       +
       

     

       43
       +
           <div class="flex gap-2 pt-2">

     

       44
       +
             {{ template "cancelButton" . }}

     

       45
       +
             {{ template "submitButton" . }}

     

       46
       +
           </div>

     

       47
       +
         </form>

     

       48
       +
       {{ end }}

     

       49
       +
       

     

       50
       +
       {{ define "kvLabelDef" }}

     

       51
       +
         <form

     

       52
       +
           hx-put="/{{ $.RepoInfo.FullName }}/settings/label"

     

       53
       +
           hx-indicator="#spinner"

     

       54
       +
           hx-swap="none"

     

       55
       +
           hx-on::after-request="if(event.detail.successful) this.reset()"

     

       56
       +
           class="flex flex-col space-y-4">

     

       57
       +
       

     

       58
       +
           <p class="text-gray-500 dark:text-gray-400">

     

       59
       +
             These labels are more detailed, they can have a key and an associated

     

       60
       +
             value. You may define additional constraints on label values.

     

       61
       +
           </p>

     

       62
       +
       

     

       63
       +
           {{ template "nameInput" . }}

     

       64
       +
           {{ template "valueInput" . }}

     

       65
       +
           {{ template "multipleInput" . }}

     

       66
       +
           {{ template "scopeInput" . }}

     

       67
       +
           {{ template "colorInput" . }}

     

       68
       +
       

     

       69
       +
           <div class="flex gap-2 pt-2">

     

       70
       +
             {{ template "cancelButton" . }}

     

       71
       +
             {{ template "submitButton" . }}

     

       72
       +
           </div>

     

       73
       +
         </form>

     

       74
       +
       {{ end }}

     

       75
       +
       

     

       76
       +
       {{ define "nameInput" }}

     

       77
        
         <div class="w-full">

     

       78
       +
           <label for="name">Name</label>

     

       79
       +
           <input class="w-full" type="text" id="label-name" name="name" required placeholder="improvement"/>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
         </div>

     

       81
       +
       {{ end }}

     

       82
        
       

     

       83
       +
       {{ define "colorInput" }}

     

       84
        
         <div class="w-full">

     

       85
        
           <label for="color">Color</label>

     

       86
        
           <div class="grid grid-cols-4 grid-rows-2 place-items-center">

     
···

       93
        
             {{ end }}

     

       94
        
           </div>

     

       95
        
         </div>

     

       96
       +
       {{ end }}

     

       97
        
       

     

       98
       +
       {{ define "scopeInput" }}

     

       99
       +
         <div class="w-full">

     

       100
       +
           <label>Scope</label>

     

       101
       +
           <label class="font-normal normal-case flex items-center gap-2 p-0">

     

       102
       +
             <input type="checkbox" id="issue-scope" name="scope" value="sh.tangled.repo.issue" checked />

     

       103
       +
             Issues

     

       104
       +
           </label>

     

       105
       +
           <label class="font-normal normal-case flex items-center gap-2 p-0">

     

       106
       +
             <input type="checkbox" id="pulls-scope" name="scope" value="sh.tangled.repo.pull" checked />

     

       107
       +
             Pull Requests

     

       108
       +
           </label>

     

       109
       +
         </div>

     

       110
       +
       {{ end }}

     

       111
       +
       

     

       112
       +
       {{ define "valueInput" }}

     

       113
       +
         <div class="w-full">

     

       114
       +
           <label for="valueType">Value Type</label>

     

       115
       +
           <select id="value-type" name="valueType" class="w-full p-3 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       116
       +
             <option value="string">String</option>

     

       117
       +
             <option value="integer">Integer</option>

     

       118
       +
           </select>

     

       119
        
         </div>

     

       120
        
       

     

       121
       +
         <div class="w-full">

     

       122
       +
           <label for="enumValues">Permitted values</label>

     

       123
       +
           <input type="text" id="enumValues" name="enumValues" placeholder="value1, value2, value3" class="w-full"/>

     

       124
       +
           <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">

     

       125
       +
           Enter comma-separated list of permitted values, or leave empty to allow any value.

     

       126
       +
           </p>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       127
        
         </div>

     

       128
       +
       

     

       129
       +
         <div class="w-full">

     

       130
       +
           <label for="valueFormat">String format</label>

     

       131
       +
           <select id="valueFormat" name="valueFormat" class="w-full p-3 rounded border border-gray-300 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-600">

     

       132
       +
             <option value="any" selected>Any</option>

     

       133
       +
             <option value="did">DID</option>

     

       134
       +
           </select>

     

       135
       +
         </div>

     

       136
       +
       {{ end }}

     

       137
       +
       

     

       138
       +
       {{ define "multipleInput" }}

     

       139
       +
        <div class="w-full flex flex-wrap gap-2">

     

       140
       +
          <input type="checkbox" id="multiple" name="multiple" value="true" />

     

       141
       +
          <span>Allow multiple values</span>

     

       142
       +
        </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       143
        
       {{ end }}

     

       144
        
       

     

       145
       +
       {{ define "cancelButton" }}

     

       146
       +
         <button

     

       147
       +
           type="button"

     

       148
       +
           popovertarget="add-labeldef-modal"

     

       149
       +
           popovertargetaction="hide"

     

       150
       +
           class="btn w-1/2 flex items-center gap-2 text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"

     

       151
       +
           >

     

       152
       +
           {{ i "x" "size-4" }} cancel

     

       153
       +
         </button>

     

       154
       +
       {{ end }}

     

       155
       +
       

     

       156
       +
       {{ define "submitButton" }}

     

       157
       +
         <button type="submit" class="btn-create w-1/2 flex items-center">

     

       158
       +
           <span class="inline-flex gap-2 items-center">{{ i "plus" "size-4" }} add</span>

     

       159
       +
           <span id="spinner" class="group">

     

       160
       +
             {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       161
       +
           </span>

     

       162
       +
         </button>

     

       163
       +
       {{ end }}

     

       164
       +
       

     

       165
       +

appview/oauth/handler/handler.go

···

       24
        
       	"tangled.org/core/appview/oauth"

     

       25
        
       	"tangled.org/core/appview/oauth/client"

     

       26
        
       	"tangled.org/core/appview/pages"

     

       0
        
       
     

       27
        
       	"tangled.org/core/idresolver"

     

       28
        
       	"tangled.org/core/rbac"

     

       29
        
       	"tangled.org/core/tid"

···

       24
        
       	"tangled.org/core/appview/oauth"

     

       25
        
       	"tangled.org/core/appview/oauth/client"

     

       26
        
       	"tangled.org/core/appview/pages"

     

       27
       +
       	"tangled.org/core/consts"

     

       28
        
       	"tangled.org/core/idresolver"

     

       29
        
       	"tangled.org/core/rbac"

     

       30
        
       	"tangled.org/core/tid"

+25 -27

appview/pages/templates/repo/settings/fragments/labelListing.html

···

       1
        
       {{ define "repo/settings/fragments/labelListing" }}

     

       2
        
         {{ $root := index . 0 }}

     

       3
        
         {{ $label := index . 1 }}

     

       4
       -
         <div id="label-{{$label.Id}}" class="flex items-center justify-between p-2 pl-4">

     

       5
       -
           <div class="flex flex-col gap-1 text-sm min-w-0 max-w-[80%]">

     

       6
       -
             {{ template "labels/fragments/labelDef" $label }}

     

       7
       -
             <div class="flex flex-wrap text items-center gap-1 text-gray-500 dark:text-gray-400">

     

       0
        
       
     

       0
        
       
     

       8
        
               {{ $label.ValueType.Type }} type

     

       9
       -
               {{ if $label.ValueType.IsEnumType }}

     

       10
       -
                 <span class="before:content-['·'] before:select-none"></span>

     

       11
       -
                 {{ join $label.ValueType.Enum ", " }}

     

       12
       -
               {{ end }}

     

       13
       -
               {{ if $label.ValueType.IsDidFormat }}

     

       14
       -
                 <span class="before:content-['·'] before:select-none"></span>

     

       15
       -
                 DID format

     

       16
       -
               {{ end }}

     

       17
       -
             </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
           </div>

     

       19
       -
           {{ if $root.RepoInfo.Roles.IsOwner }}

     

       20
       -
             <button

     

       21
       -
               class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"

     

       22
       -
               title="Delete label"

     

       23
       -
               hx-delete="/{{ $root.RepoInfo.FullName }}/settings/label"

     

       24
       -
               hx-swap="none"

     

       25
       -
               hx-vals='{"label-id": "{{ $label.Id }}"}'

     

       26
       -
               hx-confirm="Are you sure you want to delete the label `{{ $label.Name }}`?"

     

       27
       -
             >

     

       28
       -
               {{ i "trash-2" "w-5 h-5" }}

     

       29
       -
               <span class="hidden md:inline">delete</span> 

     

       30
       -
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       31
       -
             </button>

     

       32
       -
           {{ end }}

     

       33
        
         </div>

     

       34
        
       {{ end }}

···

       1
        
       {{ define "repo/settings/fragments/labelListing" }}

     

       2
        
         {{ $root := index . 0 }}

     

       3
        
         {{ $label := index . 1 }}

     

       4
       +
         <div class="flex flex-col gap-1 text-sm min-w-0 max-w-[80%]">

     

       5
       +
           {{ template "labels/fragments/labelDef" $label }}

     

       6
       +
           <div class="flex flex-wrap text items-center gap-1 text-gray-500 dark:text-gray-400">

     

       7
       +
             {{ if $label.ValueType.IsNull }} 

     

       8
       +
               basic

     

       9
       +
             {{ else }}

     

       10
        
               {{ $label.ValueType.Type }} type

     

       11
       +
             {{ end }}

     

       12
       +
       

     

       13
       +
             {{ if $label.ValueType.IsEnum }}

     

       14
       +
               <span class="before:content-['·'] before:select-none"></span>

     

       15
       +
               {{ join $label.ValueType.Enum ", " }}

     

       16
       +
             {{ end }}

     

       17
       +
       

     

       18
       +
             {{ if $label.ValueType.IsDidFormat }}

     

       19
       +
               <span class="before:content-['·'] before:select-none"></span>

     

       20
       +
               DID format

     

       21
       +
             {{ end }}

     

       22
       +
       

     

       23
       +
             {{ if $label.Multiple }}

     

       24
       +
               <span class="before:content-['·'] before:select-none"></span>

     

       25
       +
               multiple

     

       26
       +
             {{ end }}

     

       27
       +
       

     

       28
       +
             <span class="before:content-['·'] before:select-none"></span>

     

       29
       +
             {{ join $label.Scope ", " }}

     

       30
        
           </div>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
         </div>

     

       32
        
       {{ end }}

consts/consts.go

···

       1
       +
       package consts

     

       2
       +
       

     

       3
       +
       const (

     

       4
       +
       	TangledDid = "did:plc:wshs7t2adsemcrrd4snkeqli"

     

       5
       +
       	IcyDid     = "did:plc:hwevmowznbiukdf6uk5dwrrq"

     

       6
       +
       

     

       7
       +
       	DefaultSpindle = "spindle.tangled.sh"

     

       8
       +
       	DefaultKnot    = "knot1.tangled.sh"

     

       9
       +
       )

+30

appview/models/artifact.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       	"time"

     

       6
       +
       

     

       7
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       +
       	"github.com/ipfs/go-cid"

     

       10
       +
       	"tangled.org/core/api/tangled"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       type Artifact struct {

     

       14
       +
       	Id   uint64

     

       15
       +
       	Did  string

     

       16
       +
       	Rkey string

     

       17
       +
       

     

       18
       +
       	RepoAt    syntax.ATURI

     

       19
       +
       	Tag       plumbing.Hash

     

       20
       +
       	CreatedAt time.Time

     

       21
       +
       

     

       22
       +
       	BlobCid  cid.Cid

     

       23
       +
       	Name     string

     

       24
       +
       	Size     uint64

     

       25
       +
       	MimeType string

     

       26
       +
       }

     

       27
       +
       

     

       28
       +
       func (a *Artifact) ArtifactAt() syntax.ATURI {

     

       29
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey))

     

       30
       +
       }

+21

appview/models/collaborator.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type Collaborator struct {

     

       10
       +
       	// identifiers for the record

     

       11
       +
       	Id   int64

     

       12
       +
       	Did  syntax.DID

     

       13
       +
       	Rkey string

     

       14
       +
       

     

       15
       +
       	// content

     

       16
       +
       	SubjectDid syntax.DID

     

       17
       +
       	RepoAt     syntax.ATURI

     

       18
       +
       

     

       19
       +
       	// meta

     

       20
       +
       	Created time.Time

     

       21
       +
       }

+16

appview/models/email.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type Email struct {

     

       8
       +
       	ID               int64

     

       9
       +
       	Did              string

     

       10
       +
       	Address          string

     

       11
       +
       	Verified         bool

     

       12
       +
       	Primary          bool

     

       13
       +
       	VerificationCode string

     

       14
       +
       	LastSent         *time.Time

     

       15
       +
       	CreatedAt        time.Time

     

       16
       +
       }

+26 -57

appview/db/follow.go

···

       5
        
       	"log"

     

       6
        
       	"strings"

     

       7
        
       	"time"

     

       8
       -
       )

     

       9
        
       

     

       10
       -
       type Follow struct {

     

       11
       -
       	UserDid    string

     

       12
       -
       	SubjectDid string

     

       13
       -
       	FollowedAt time.Time

     

       14
       -
       	Rkey       string

     

       15
       -
       }

     

       16
        
       

     

       17
       -
       func AddFollow(e Execer, follow *Follow) error {

     

       18
        
       	query := `insert or ignore into follows (user_did, subject_did, rkey) values (?, ?, ?)`

     

       19
        
       	_, err := e.Exec(query, follow.UserDid, follow.SubjectDid, follow.Rkey)

     

       20
        
       	return err

     

       21
        
       }

     

       22
        
       

     

       23
        
       // Get a follow record

     

       24
       -
       func GetFollow(e Execer, userDid, subjectDid string) (*Follow, error) {

     

       25
        
       	query := `select user_did, subject_did, followed_at, rkey from follows where user_did = ? and subject_did = ?`

     

       26
        
       	row := e.QueryRow(query, userDid, subjectDid)

     

       27
        
       

     

       28
       -
       	var follow Follow

     

       29
        
       	var followedAt string

     

       30
        
       	err := row.Scan(&follow.UserDid, &follow.SubjectDid, &followedAt, &follow.Rkey)

     

       31
        
       	if err != nil {

     
···

       55
        
       	return err

     

       56
        
       }

     

       57
        
       

     

       58
       -
       type FollowStats struct {

     

       59
       -
       	Followers int64

     

       60
       -
       	Following int64

     

       61
       -
       }

     

       62
       -
       

     

       63
       -
       func GetFollowerFollowingCount(e Execer, did string) (FollowStats, error) {

     

       64
        
       	var followers, following int64

     

       65
        
       	err := e.QueryRow(

     

       66
        
       		`SELECT

     
···

       68
        
       		COUNT(CASE WHEN user_did = ? THEN 1 END) AS following

     

       69
        
       		FROM follows;`, did, did).Scan(&followers, &following)

     

       70
        
       	if err != nil {

     

       71
       -
       		return FollowStats{}, err

     

       72
        
       	}

     

       73
       -
       	return FollowStats{

     

       74
        
       		Followers: followers,

     

       75
        
       		Following: following,

     

       76
        
       	}, nil

     

       77
        
       }

     

       78
        
       

     

       79
       -
       func GetFollowerFollowingCounts(e Execer, dids []string) (map[string]FollowStats, error) {

     

       80
        
       	if len(dids) == 0 {

     

       81
        
       		return nil, nil

     

       82
        
       	}

     
···

       112
        
       		) g on f.did = g.did`,

     

       113
        
       		placeholderStr, placeholderStr)

     

       114
        
       

     

       115
       -
       	result := make(map[string]FollowStats)

     

       116
        
       

     

       117
        
       	rows, err := e.Query(query, args...)

     

       118
        
       	if err != nil {

     
···

       126
        
       		if err := rows.Scan(&did, &followers, &following); err != nil {

     

       127
        
       			return nil, err

     

       128
        
       		}

     

       129
       -
       		result[did] = FollowStats{

     

       130
        
       			Followers: followers,

     

       131
        
       			Following: following,

     

       132
        
       		}

     
···

       134
        
       

     

       135
        
       	for _, did := range dids {

     

       136
        
       		if _, exists := result[did]; !exists {

     

       137
       -
       			result[did] = FollowStats{

     

       138
        
       				Followers: 0,

     

       139
        
       				Following: 0,

     

       140
        
       			}

     
···

       144
        
       	return result, nil

     

       145
        
       }

     

       146
        
       

     

       147
       -
       func GetFollows(e Execer, limit int, filters ...filter) ([]Follow, error) {

     

       148
       -
       	var follows []Follow

     

       149
        
       

     

       150
        
       	var conditions []string

     

       151
        
       	var args []any

     
···

       177
        
       		return nil, err

     

       178
        
       	}

     

       179
        
       	for rows.Next() {

     

       180
       -
       		var follow Follow

     

       181
        
       		var followedAt string

     

       182
        
       		err := rows.Scan(

     

       183
        
       			&follow.UserDid,

     
···

       200
        
       	return follows, nil

     

       201
        
       }

     

       202
        
       

     

       203
       -
       func GetFollowers(e Execer, did string) ([]Follow, error) {

     

       204
        
       	return GetFollows(e, 0, FilterEq("subject_did", did))

     

       205
        
       }

     

       206
        
       

     

       207
       -
       func GetFollowing(e Execer, did string) ([]Follow, error) {

     

       208
        
       	return GetFollows(e, 0, FilterEq("user_did", did))

     

       209
        
       }

     

       210
        
       

     

       211
       -
       type FollowStatus int

     

       212
       -
       

     

       213
       -
       const (

     

       214
       -
       	IsNotFollowing FollowStatus = iota

     

       215
       -
       	IsFollowing

     

       216
       -
       	IsSelf

     

       217
       -
       )

     

       218
       -
       

     

       219
       -
       func (s FollowStatus) String() string {

     

       220
       -
       	switch s {

     

       221
       -
       	case IsNotFollowing:

     

       222
       -
       		return "IsNotFollowing"

     

       223
       -
       	case IsFollowing:

     

       224
       -
       		return "IsFollowing"

     

       225
       -
       	case IsSelf:

     

       226
       -
       		return "IsSelf"

     

       227
       -
       	default:

     

       228
       -
       		return "IsNotFollowing"

     

       229
       -
       	}

     

       230
       -
       }

     

       231
       -
       

     

       232
       -
       func getFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]FollowStatus, error) {

     

       233
        
       	if len(subjectDids) == 0 || userDid == "" {

     

       234
       -
       		return make(map[string]FollowStatus), nil

     

       235
        
       	}

     

       236
        
       

     

       237
       -
       	result := make(map[string]FollowStatus)

     

       238
        
       

     

       239
        
       	for _, subjectDid := range subjectDids {

     

       240
        
       		if userDid == subjectDid {

     

       241
       -
       			result[subjectDid] = IsSelf

     

       242
        
       		} else {

     

       243
       -
       			result[subjectDid] = IsNotFollowing

     

       244
        
       		}

     

       245
        
       	}

     

       246
        
       

     
···

       281
        
       		if err := rows.Scan(&subjectDid); err != nil {

     

       282
        
       			return nil, err

     

       283
        
       		}

     

       284
       -
       		result[subjectDid] = IsFollowing

     

       285
        
       	}

     

       286
        
       

     

       287
        
       	return result, nil

     

       288
        
       }

     

       289
        
       

     

       290
       -
       func GetFollowStatus(e Execer, userDid, subjectDid string) FollowStatus {

     

       291
        
       	statuses, err := getFollowStatuses(e, userDid, []string{subjectDid})

     

       292
        
       	if err != nil {

     

       293
       -
       		return IsNotFollowing

     

       294
        
       	}

     

       295
        
       	return statuses[subjectDid]

     

       296
        
       }

     

       297
        
       

     

       298
       -
       func GetFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]FollowStatus, error) {

     

       299
        
       	return getFollowStatuses(e, userDid, subjectDids)

     

       300
        
       }

···

       5
        
       	"log"

     

       6
        
       	"strings"

     

       7
        
       	"time"

     

       0
        
       
     

       8
        
       

     

       9
       +
       	"tangled.org/core/appview/models"

     

       10
       +
       )

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       11
        
       

     

       12
       +
       func AddFollow(e Execer, follow *models.Follow) error {

     

       13
        
       	query := `insert or ignore into follows (user_did, subject_did, rkey) values (?, ?, ?)`

     

       14
        
       	_, err := e.Exec(query, follow.UserDid, follow.SubjectDid, follow.Rkey)

     

       15
        
       	return err

     

       16
        
       }

     

       17
        
       

     

       18
        
       // Get a follow record

     

       19
       +
       func GetFollow(e Execer, userDid, subjectDid string) (*models.Follow, error) {

     

       20
        
       	query := `select user_did, subject_did, followed_at, rkey from follows where user_did = ? and subject_did = ?`

     

       21
        
       	row := e.QueryRow(query, userDid, subjectDid)

     

       22
        
       

     

       23
       +
       	var follow models.Follow

     

       24
        
       	var followedAt string

     

       25
        
       	err := row.Scan(&follow.UserDid, &follow.SubjectDid, &followedAt, &follow.Rkey)

     

       26
        
       	if err != nil {

     
···

       50
        
       	return err

     

       51
        
       }

     

       52
        
       

     

       53
       +
       func GetFollowerFollowingCount(e Execer, did string) (models.FollowStats, error) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       54
        
       	var followers, following int64

     

       55
        
       	err := e.QueryRow(

     

       56
        
       		`SELECT

     
···

       58
        
       		COUNT(CASE WHEN user_did = ? THEN 1 END) AS following

     

       59
        
       		FROM follows;`, did, did).Scan(&followers, &following)

     

       60
        
       	if err != nil {

     

       61
       +
       		return models.FollowStats{}, err

     

       62
        
       	}

     

       63
       +
       	return models.FollowStats{

     

       64
        
       		Followers: followers,

     

       65
        
       		Following: following,

     

       66
        
       	}, nil

     

       67
        
       }

     

       68
        
       

     

       69
       +
       func GetFollowerFollowingCounts(e Execer, dids []string) (map[string]models.FollowStats, error) {

     

       70
        
       	if len(dids) == 0 {

     

       71
        
       		return nil, nil

     

       72
        
       	}

     
···

       102
        
       		) g on f.did = g.did`,

     

       103
        
       		placeholderStr, placeholderStr)

     

       104
        
       

     

       105
       +
       	result := make(map[string]models.FollowStats)

     

       106
        
       

     

       107
        
       	rows, err := e.Query(query, args...)

     

       108
        
       	if err != nil {

     
···

       116
        
       		if err := rows.Scan(&did, &followers, &following); err != nil {

     

       117
        
       			return nil, err

     

       118
        
       		}

     

       119
       +
       		result[did] = models.FollowStats{

     

       120
        
       			Followers: followers,

     

       121
        
       			Following: following,

     

       122
        
       		}

     
···

       124
        
       

     

       125
        
       	for _, did := range dids {

     

       126
        
       		if _, exists := result[did]; !exists {

     

       127
       +
       			result[did] = models.FollowStats{

     

       128
        
       				Followers: 0,

     

       129
        
       				Following: 0,

     

       130
        
       			}

     
···

       134
        
       	return result, nil

     

       135
        
       }

     

       136
        
       

     

       137
       +
       func GetFollows(e Execer, limit int, filters ...filter) ([]models.Follow, error) {

     

       138
       +
       	var follows []models.Follow

     

       139
        
       

     

       140
        
       	var conditions []string

     

       141
        
       	var args []any

     
···

       167
        
       		return nil, err

     

       168
        
       	}

     

       169
        
       	for rows.Next() {

     

       170
       +
       		var follow models.Follow

     

       171
        
       		var followedAt string

     

       172
        
       		err := rows.Scan(

     

       173
        
       			&follow.UserDid,

     
···

       190
        
       	return follows, nil

     

       191
        
       }

     

       192
        
       

     

       193
       +
       func GetFollowers(e Execer, did string) ([]models.Follow, error) {

     

       194
        
       	return GetFollows(e, 0, FilterEq("subject_did", did))

     

       195
        
       }

     

       196
        
       

     

       197
       +
       func GetFollowing(e Execer, did string) ([]models.Follow, error) {

     

       198
        
       	return GetFollows(e, 0, FilterEq("user_did", did))

     

       199
        
       }

     

       200
        
       

     

       201
       +
       func getFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]models.FollowStatus, error) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       202
        
       	if len(subjectDids) == 0 || userDid == "" {

     

       203
       +
       		return make(map[string]models.FollowStatus), nil

     

       204
        
       	}

     

       205
        
       

     

       206
       +
       	result := make(map[string]models.FollowStatus)

     

       207
        
       

     

       208
        
       	for _, subjectDid := range subjectDids {

     

       209
        
       		if userDid == subjectDid {

     

       210
       +
       			result[subjectDid] = models.IsSelf

     

       211
        
       		} else {

     

       212
       +
       			result[subjectDid] = models.IsNotFollowing

     

       213
        
       		}

     

       214
        
       	}

     

       215
        
       

     
···

       250
        
       		if err := rows.Scan(&subjectDid); err != nil {

     

       251
        
       			return nil, err

     

       252
        
       		}

     

       253
       +
       		result[subjectDid] = models.IsFollowing

     

       254
        
       	}

     

       255
        
       

     

       256
        
       	return result, nil

     

       257
        
       }

     

       258
        
       

     

       259
       +
       func GetFollowStatus(e Execer, userDid, subjectDid string) models.FollowStatus {

     

       260
        
       	statuses, err := getFollowStatuses(e, userDid, []string{subjectDid})

     

       261
        
       	if err != nil {

     

       262
       +
       		return models.IsNotFollowing

     

       263
        
       	}

     

       264
        
       	return statuses[subjectDid]

     

       265
        
       }

     

       266
        
       

     

       267
       +
       func GetFollowStatuses(e Execer, userDid string, subjectDids []string) (map[string]models.FollowStatus, error) {

     

       268
        
       	return getFollowStatuses(e, userDid, subjectDids)

     

       269
        
       }

+38

appview/models/follow.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type Follow struct {

     

       8
       +
       	UserDid    string

     

       9
       +
       	SubjectDid string

     

       10
       +
       	FollowedAt time.Time

     

       11
       +
       	Rkey       string

     

       12
       +
       }

     

       13
       +
       

     

       14
       +
       type FollowStats struct {

     

       15
       +
       	Followers int64

     

       16
       +
       	Following int64

     

       17
       +
       }

     

       18
       +
       

     

       19
       +
       type FollowStatus int

     

       20
       +
       

     

       21
       +
       const (

     

       22
       +
       	IsNotFollowing FollowStatus = iota

     

       23
       +
       	IsFollowing

     

       24
       +
       	IsSelf

     

       25
       +
       )

     

       26
       +
       

     

       27
       +
       func (s FollowStatus) String() string {

     

       28
       +
       	switch s {

     

       29
       +
       	case IsNotFollowing:

     

       30
       +
       		return "IsNotFollowing"

     

       31
       +
       	case IsFollowing:

     

       32
       +
       		return "IsFollowing"

     

       33
       +
       	case IsSelf:

     

       34
       +
       		return "IsSelf"

     

       35
       +
       	default:

     

       36
       +
       		return "IsNotFollowing"

     

       37
       +
       	}

     

       38
       +
       }

+2 -1

appview/knots/knots.go

···

       13
        
       	"tangled.org/core/appview/config"

     

       14
        
       	"tangled.org/core/appview/db"

     

       15
        
       	"tangled.org/core/appview/middleware"

     

       0
        
       
     

       16
        
       	"tangled.org/core/appview/oauth"

     

       17
        
       	"tangled.org/core/appview/pages"

     

       18
        
       	"tangled.org/core/appview/serververify"

     
···

       119
        
       	}

     

       120
        
       

     

       121
        
       	// organize repos by did

     

       122
       -
       	repoMap := make(map[string][]db.Repo)

     

       123
        
       	for _, r := range repos {

     

       124
        
       		repoMap[r.Did] = append(repoMap[r.Did], r)

     

       125
        
       	}

···

       13
        
       	"tangled.org/core/appview/config"

     

       14
        
       	"tangled.org/core/appview/db"

     

       15
        
       	"tangled.org/core/appview/middleware"

     

       16
       +
       	"tangled.org/core/appview/models"

     

       17
        
       	"tangled.org/core/appview/oauth"

     

       18
        
       	"tangled.org/core/appview/pages"

     

       19
        
       	"tangled.org/core/appview/serververify"

     
···

       120
        
       	}

     

       121
        
       

     

       122
        
       	// organize repos by did

     

       123
       +
       	repoMap := make(map[string][]models.Repo)

     

       124
        
       	for _, r := range repos {

     

       125
        
       		repoMap[r.Did] = append(repoMap[r.Did], r)

     

       126
        
       	}

+3 -3

appview/pages/repoinfo/repoinfo.go

···

       7
        
       	"strings"

     

       8
        
       

     

       9
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
       -
       	"tangled.org/core/appview/db"

     

       11
        
       	"tangled.org/core/appview/state/userutil"

     

       12
        
       )

     

       13
        
       

     
···

       60
        
       	Spindle      string

     

       61
        
       	RepoAt       syntax.ATURI

     

       62
        
       	IsStarred    bool

     

       63
       -
       	Stats        db.RepoStats

     

       64
        
       	Roles        RolesInRepo

     

       65
       -
       	Source       *db.Repo

     

       66
        
       	SourceHandle string

     

       67
        
       	Ref          string

     

       68
        
       	DisableFork  bool

···

       7
        
       	"strings"

     

       8
        
       

     

       9
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
       +
       	"tangled.org/core/appview/models"

     

       11
        
       	"tangled.org/core/appview/state/userutil"

     

       12
        
       )

     

       13
        
       

     
···

       60
        
       	Spindle      string

     

       61
        
       	RepoAt       syntax.ATURI

     

       62
        
       	IsStarred    bool

     

       63
       +
       	Stats        models.RepoStats

     

       64
        
       	Roles        RolesInRepo

     

       65
       +
       	Source       *models.Repo

     

       66
        
       	SourceHandle string

     

       67
        
       	Ref          string

     

       68
        
       	DisableFork  bool

+15 -200

appview/db/issues.go

···

       10
        
       	"time"

     

       11
        
       

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       -
       	"tangled.org/core/api/tangled"

     

       14
        
       	"tangled.org/core/appview/models"

     

       15
        
       	"tangled.org/core/appview/pagination"

     

       16
        
       )

     

       17
        
       

     

       18
       -
       type Issue struct {

     

       19
       -
       	Id      int64

     

       20
       -
       	Did     string

     

       21
       -
       	Rkey    string

     

       22
       -
       	RepoAt  syntax.ATURI

     

       23
       -
       	IssueId int

     

       24
       -
       	Created time.Time

     

       25
       -
       	Edited  *time.Time

     

       26
       -
       	Deleted *time.Time

     

       27
       -
       	Title   string

     

       28
       -
       	Body    string

     

       29
       -
       	Open    bool

     

       30
       -
       

     

       31
       -
       	// optionally, populate this when querying for reverse mappings

     

       32
       -
       	// like comment counts, parent repo etc.

     

       33
       -
       	Comments []IssueComment

     

       34
       -
       	Labels   models.LabelState

     

       35
       -
       	Repo     *models.Repo

     

       36
       -
       }

     

       37
       -
       

     

       38
       -
       func (i *Issue) AtUri() syntax.ATURI {

     

       39
       -
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueNSID, i.Rkey))

     

       40
       -
       }

     

       41
       -
       

     

       42
       -
       func (i *Issue) AsRecord() tangled.RepoIssue {

     

       43
       -
       	return tangled.RepoIssue{

     

       44
       -
       		Repo:      i.RepoAt.String(),

     

       45
       -
       		Title:     i.Title,

     

       46
       -
       		Body:      &i.Body,

     

       47
       -
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       48
       -
       	}

     

       49
       -
       }

     

       50
       -
       

     

       51
       -
       func (i *Issue) State() string {

     

       52
       -
       	if i.Open {

     

       53
       -
       		return "open"

     

       54
       -
       	}

     

       55
       -
       	return "closed"

     

       56
       -
       }

     

       57
       -
       

     

       58
       -
       type CommentListItem struct {

     

       59
       -
       	Self    *IssueComment

     

       60
       -
       	Replies []*IssueComment

     

       61
       -
       }

     

       62
       -
       

     

       63
       -
       func (i *Issue) CommentList() []CommentListItem {

     

       64
       -
       	// Create a map to quickly find comments by their aturi

     

       65
       -
       	toplevel := make(map[string]*CommentListItem)

     

       66
       -
       	var replies []*IssueComment

     

       67
       -
       

     

       68
       -
       	// collect top level comments into the map

     

       69
       -
       	for _, comment := range i.Comments {

     

       70
       -
       		if comment.IsTopLevel() {

     

       71
       -
       			toplevel[comment.AtUri().String()] = &CommentListItem{

     

       72
       -
       				Self: &comment,

     

       73
       -
       			}

     

       74
       -
       		} else {

     

       75
       -
       			replies = append(replies, &comment)

     

       76
       -
       		}

     

       77
       -
       	}

     

       78
       -
       

     

       79
       -
       	for _, r := range replies {

     

       80
       -
       		parentAt := *r.ReplyTo

     

       81
       -
       		if parent, exists := toplevel[parentAt]; exists {

     

       82
       -
       			parent.Replies = append(parent.Replies, r)

     

       83
       -
       		}

     

       84
       -
       	}

     

       85
       -
       

     

       86
       -
       	var listing []CommentListItem

     

       87
       -
       	for _, v := range toplevel {

     

       88
       -
       		listing = append(listing, *v)

     

       89
       -
       	}

     

       90
       -
       

     

       91
       -
       	// sort everything

     

       92
       -
       	sortFunc := func(a, b *IssueComment) bool {

     

       93
       -
       		return a.Created.Before(b.Created)

     

       94
       -
       	}

     

       95
       -
       	sort.Slice(listing, func(i, j int) bool {

     

       96
       -
       		return sortFunc(listing[i].Self, listing[j].Self)

     

       97
       -
       	})

     

       98
       -
       	for _, r := range listing {

     

       99
       -
       		sort.Slice(r.Replies, func(i, j int) bool {

     

       100
       -
       			return sortFunc(r.Replies[i], r.Replies[j])

     

       101
       -
       		})

     

       102
       -
       	}

     

       103
       -
       

     

       104
       -
       	return listing

     

       105
       -
       }

     

       106
       -
       

     

       107
       -
       func (i *Issue) Participants() []string {

     

       108
       -
       	participantSet := make(map[string]struct{})

     

       109
       -
       	participants := []string{}

     

       110
       -
       

     

       111
       -
       	addParticipant := func(did string) {

     

       112
       -
       		if _, exists := participantSet[did]; !exists {

     

       113
       -
       			participantSet[did] = struct{}{}

     

       114
       -
       			participants = append(participants, did)

     

       115
       -
       		}

     

       116
       -
       	}

     

       117
       -
       

     

       118
       -
       	addParticipant(i.Did)

     

       119
       -
       

     

       120
       -
       	for _, c := range i.Comments {

     

       121
       -
       		addParticipant(c.Did)

     

       122
       -
       	}

     

       123
       -
       

     

       124
       -
       	return participants

     

       125
       -
       }

     

       126
       -
       

     

       127
       -
       func IssueFromRecord(did, rkey string, record tangled.RepoIssue) Issue {

     

       128
       -
       	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       129
       -
       	if err != nil {

     

       130
       -
       		created = time.Now()

     

       131
       -
       	}

     

       132
       -
       

     

       133
       -
       	body := ""

     

       134
       -
       	if record.Body != nil {

     

       135
       -
       		body = *record.Body

     

       136
       -
       	}

     

       137
       -
       

     

       138
       -
       	return Issue{

     

       139
       -
       		RepoAt:  syntax.ATURI(record.Repo),

     

       140
       -
       		Did:     did,

     

       141
       -
       		Rkey:    rkey,

     

       142
       -
       		Created: created,

     

       143
       -
       		Title:   record.Title,

     

       144
       -
       		Body:    body,

     

       145
       -
       		Open:    true, // new issues are open by default

     

       146
       -
       	}

     

       147
       -
       }

     

       148
       -
       

     

       149
       -
       type IssueComment struct {

     

       150
       -
       	Id      int64

     

       151
       -
       	Did     string

     

       152
       -
       	Rkey    string

     

       153
       -
       	IssueAt string

     

       154
       -
       	ReplyTo *string

     

       155
       -
       	Body    string

     

       156
       -
       	Created time.Time

     

       157
       -
       	Edited  *time.Time

     

       158
       -
       	Deleted *time.Time

     

       159
       -
       }

     

       160
       -
       

     

       161
       -
       func (i *IssueComment) AtUri() syntax.ATURI {

     

       162
       -
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueCommentNSID, i.Rkey))

     

       163
       -
       }

     

       164
       -
       

     

       165
       -
       func (i *IssueComment) AsRecord() tangled.RepoIssueComment {

     

       166
       -
       	return tangled.RepoIssueComment{

     

       167
       -
       		Body:      i.Body,

     

       168
       -
       		Issue:     i.IssueAt,

     

       169
       -
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       170
       -
       		ReplyTo:   i.ReplyTo,

     

       171
       -
       	}

     

       172
       -
       }

     

       173
       -
       

     

       174
       -
       func (i *IssueComment) IsTopLevel() bool {

     

       175
       -
       	return i.ReplyTo == nil

     

       176
       -
       }

     

       177
       -
       

     

       178
       -
       func IssueCommentFromRecord(did, rkey string, record tangled.RepoIssueComment) (*IssueComment, error) {

     

       179
       -
       	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       180
       -
       	if err != nil {

     

       181
       -
       		created = time.Now()

     

       182
       -
       	}

     

       183
       -
       

     

       184
       -
       	ownerDid := did

     

       185
       -
       

     

       186
       -
       	if _, err = syntax.ParseATURI(record.Issue); err != nil {

     

       187
       -
       		return nil, err

     

       188
       -
       	}

     

       189
       -
       

     

       190
       -
       	comment := IssueComment{

     

       191
       -
       		Did:     ownerDid,

     

       192
       -
       		Rkey:    rkey,

     

       193
       -
       		Body:    record.Body,

     

       194
       -
       		IssueAt: record.Issue,

     

       195
       -
       		ReplyTo: record.ReplyTo,

     

       196
       -
       		Created: created,

     

       197
       -
       	}

     

       198
       -
       

     

       199
       -
       	return &comment, nil

     

       200
       -
       }

     

       201
       -
       

     

       202
       -
       func PutIssue(tx *sql.Tx, issue *Issue) error {

     

       203
        
       	// ensure sequence exists

     

       204
        
       	_, err := tx.Exec(`

     

       205
        
       		insert or ignore into repo_issue_seqs (repo_at, next_issue_id)

     
···

       234
        
       	}

     

       235
        
       }

     

       236
        
       

     

       237
       -
       func createNewIssue(tx *sql.Tx, issue *Issue) error {

     

       238
        
       	// get next issue_id

     

       239
        
       	var newIssueId int

     

       240
        
       	err := tx.QueryRow(`

     
···

       257
        
       	return row.Scan(&issue.Id, &issue.IssueId)

     

       258
        
       }

     

       259
        
       

     

       260
       -
       func updateIssue(tx *sql.Tx, issue *Issue) error {

     

       261
        
       	// update existing issue

     

       262
        
       	_, err := tx.Exec(`

     

       263
        
       		update issues

     
···

       267
        
       	return err

     

       268
        
       }

     

       269
        
       

     

       270
       -
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]Issue, error) {

     

       271
       -
       	issueMap := make(map[string]*Issue) // at-uri -> issue

     

       272
        
       

     

       273
        
       	var conditions []string

     

       274
        
       	var args []any

     
···

       323
        
       	defer rows.Close()

     

       324
        
       

     

       325
        
       	for rows.Next() {

     

       326
       -
       		var issue Issue

     

       327
        
       		var createdAt string

     

       328
        
       		var editedAt, deletedAt sql.Null[string]

     

       329
        
       		var rowNum int64

     
···

       416
        
       		}

     

       417
        
       	}

     

       418
        
       

     

       419
       -
       	var issues []Issue

     

       420
        
       	for _, i := range issueMap {

     

       421
        
       		issues = append(issues, *i)

     

       422
        
       	}

     
···

       428
        
       	return issues, nil

     

       429
        
       }

     

       430
        
       

     

       431
       -
       func GetIssues(e Execer, filters ...filter) ([]Issue, error) {

     

       432
        
       	return GetIssuesPaginated(e, pagination.FirstPage(), filters...)

     

       433
        
       }

     

       434
        
       

     

       435
       -
       func GetIssue(e Execer, repoAt syntax.ATURI, issueId int) (*Issue, error) {

     

       436
        
       	query := `select id, owner_did, rkey, created, title, body, open from issues where repo_at = ? and issue_id = ?`

     

       437
        
       	row := e.QueryRow(query, repoAt, issueId)

     

       438
        
       

     

       439
       -
       	var issue Issue

     

       440
        
       	var createdAt string

     

       441
        
       	err := row.Scan(&issue.Id, &issue.Did, &issue.Rkey, &createdAt, &issue.Title, &issue.Body, &issue.Open)

     

       442
        
       	if err != nil {

     
···

       452
        
       	return &issue, nil

     

       453
        
       }

     

       454
        
       

     

       455
       -
       func AddIssueComment(e Execer, c IssueComment) (int64, error) {

     

       456
        
       	result, err := e.Exec(

     

       457
        
       		`insert into issue_comments (

     

       458
        
       			did,

     
···

       514
        
       	return err

     

       515
        
       }

     

       516
        
       

     

       517
       -
       func GetIssueComments(e Execer, filters ...filter) ([]IssueComment, error) {

     

       518
       -
       	var comments []IssueComment

     

       519
        
       

     

       520
        
       	var conditions []string

     

       521
        
       	var args []any

     
···

       551
        
       	}

     

       552
        
       

     

       553
        
       	for rows.Next() {

     

       554
       -
       		var comment IssueComment

     

       555
        
       		var created string

     

       556
        
       		var rkey, edited, deleted, replyTo sql.Null[string]

     

       557
        
       		err := rows.Scan(

     
···

       670
        
       

     

       671
        
       	var count models.IssueCount

     

       672
        
       	if err := row.Scan(&count.Open, &count.Closed); err != nil {

     

       673
       -
       		return models.IssueCount{0, 0}, err

     

       674
        
       	}

     

       675
        
       

     

       676
        
       	return count, nil

···

       10
        
       	"time"

     

       11
        
       

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       0
        
       
     

       13
        
       	"tangled.org/core/appview/models"

     

       14
        
       	"tangled.org/core/appview/pagination"

     

       15
        
       )

     

       16
        
       

     

       17
       +
       func PutIssue(tx *sql.Tx, issue *models.Issue) error {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       	// ensure sequence exists

     

       19
        
       	_, err := tx.Exec(`

     

       20
        
       		insert or ignore into repo_issue_seqs (repo_at, next_issue_id)

     
···

       49
        
       	}

     

       50
        
       }

     

       51
        
       

     

       52
       +
       func createNewIssue(tx *sql.Tx, issue *models.Issue) error {

     

       53
        
       	// get next issue_id

     

       54
        
       	var newIssueId int

     

       55
        
       	err := tx.QueryRow(`

     
···

       72
        
       	return row.Scan(&issue.Id, &issue.IssueId)

     

       73
        
       }

     

       74
        
       

     

       75
       +
       func updateIssue(tx *sql.Tx, issue *models.Issue) error {

     

       76
        
       	// update existing issue

     

       77
        
       	_, err := tx.Exec(`

     

       78
        
       		update issues

     
···

       82
        
       	return err

     

       83
        
       }

     

       84
        
       

     

       85
       +
       func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) {

     

       86
       +
       	issueMap := make(map[string]*models.Issue) // at-uri -> issue

     

       87
        
       

     

       88
        
       	var conditions []string

     

       89
        
       	var args []any

     
···

       138
        
       	defer rows.Close()

     

       139
        
       

     

       140
        
       	for rows.Next() {

     

       141
       +
       		var issue models.Issue

     

       142
        
       		var createdAt string

     

       143
        
       		var editedAt, deletedAt sql.Null[string]

     

       144
        
       		var rowNum int64

     
···

       231
        
       		}

     

       232
        
       	}

     

       233
        
       

     

       234
       +
       	var issues []models.Issue

     

       235
        
       	for _, i := range issueMap {

     

       236
        
       		issues = append(issues, *i)

     

       237
        
       	}

     
···

       243
        
       	return issues, nil

     

       244
        
       }

     

       245
        
       

     

       246
       +
       func GetIssues(e Execer, filters ...filter) ([]models.Issue, error) {

     

       247
        
       	return GetIssuesPaginated(e, pagination.FirstPage(), filters...)

     

       248
        
       }

     

       249
        
       

     

       250
       +
       func GetIssue(e Execer, repoAt syntax.ATURI, issueId int) (*models.Issue, error) {

     

       251
        
       	query := `select id, owner_did, rkey, created, title, body, open from issues where repo_at = ? and issue_id = ?`

     

       252
        
       	row := e.QueryRow(query, repoAt, issueId)

     

       253
        
       

     

       254
       +
       	var issue models.Issue

     

       255
        
       	var createdAt string

     

       256
        
       	err := row.Scan(&issue.Id, &issue.Did, &issue.Rkey, &createdAt, &issue.Title, &issue.Body, &issue.Open)

     

       257
        
       	if err != nil {

     
···

       267
        
       	return &issue, nil

     

       268
        
       }

     

       269
        
       

     

       270
       +
       func AddIssueComment(e Execer, c models.IssueComment) (int64, error) {

     

       271
        
       	result, err := e.Exec(

     

       272
        
       		`insert into issue_comments (

     

       273
        
       			did,

     
···

       329
        
       	return err

     

       330
        
       }

     

       331
        
       

     

       332
       +
       func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) {

     

       333
       +
       	var comments []models.IssueComment

     

       334
        
       

     

       335
        
       	var conditions []string

     

       336
        
       	var args []any

     
···

       366
        
       	}

     

       367
        
       

     

       368
        
       	for rows.Next() {

     

       369
       +
       		var comment models.IssueComment

     

       370
        
       		var created string

     

       371
        
       		var rkey, edited, deleted, replyTo sql.Null[string]

     

       372
        
       		err := rows.Scan(

     
···

       485
        
       

     

       486
        
       	var count models.IssueCount

     

       487
        
       	if err := row.Scan(&count.Open, &count.Closed); err != nil {

     

       488
       +
       		return models.IssueCount{}, err

     

       489
        
       	}

     

       490
        
       

     

       491
        
       	return count, nil

+194

appview/models/issue.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       	"sort"

     

       6
       +
       	"time"

     

       7
       +
       

     

       8
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       +
       )

     

       11
       +
       

     

       12
       +
       type Issue struct {

     

       13
       +
       	Id      int64

     

       14
       +
       	Did     string

     

       15
       +
       	Rkey    string

     

       16
       +
       	RepoAt  syntax.ATURI

     

       17
       +
       	IssueId int

     

       18
       +
       	Created time.Time

     

       19
       +
       	Edited  *time.Time

     

       20
       +
       	Deleted *time.Time

     

       21
       +
       	Title   string

     

       22
       +
       	Body    string

     

       23
       +
       	Open    bool

     

       24
       +
       

     

       25
       +
       	// optionally, populate this when querying for reverse mappings

     

       26
       +
       	// like comment counts, parent repo etc.

     

       27
       +
       	Comments []IssueComment

     

       28
       +
       	Labels   LabelState

     

       29
       +
       	Repo     *Repo

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       func (i *Issue) AtUri() syntax.ATURI {

     

       33
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueNSID, i.Rkey))

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       func (i *Issue) AsRecord() tangled.RepoIssue {

     

       37
       +
       	return tangled.RepoIssue{

     

       38
       +
       		Repo:      i.RepoAt.String(),

     

       39
       +
       		Title:     i.Title,

     

       40
       +
       		Body:      &i.Body,

     

       41
       +
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       42
       +
       	}

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       func (i *Issue) State() string {

     

       46
       +
       	if i.Open {

     

       47
       +
       		return "open"

     

       48
       +
       	}

     

       49
       +
       	return "closed"

     

       50
       +
       }

     

       51
       +
       

     

       52
       +
       type CommentListItem struct {

     

       53
       +
       	Self    *IssueComment

     

       54
       +
       	Replies []*IssueComment

     

       55
       +
       }

     

       56
       +
       

     

       57
       +
       func (i *Issue) CommentList() []CommentListItem {

     

       58
       +
       	// Create a map to quickly find comments by their aturi

     

       59
       +
       	toplevel := make(map[string]*CommentListItem)

     

       60
       +
       	var replies []*IssueComment

     

       61
       +
       

     

       62
       +
       	// collect top level comments into the map

     

       63
       +
       	for _, comment := range i.Comments {

     

       64
       +
       		if comment.IsTopLevel() {

     

       65
       +
       			toplevel[comment.AtUri().String()] = &CommentListItem{

     

       66
       +
       				Self: &comment,

     

       67
       +
       			}

     

       68
       +
       		} else {

     

       69
       +
       			replies = append(replies, &comment)

     

       70
       +
       		}

     

       71
       +
       	}

     

       72
       +
       

     

       73
       +
       	for _, r := range replies {

     

       74
       +
       		parentAt := *r.ReplyTo

     

       75
       +
       		if parent, exists := toplevel[parentAt]; exists {

     

       76
       +
       			parent.Replies = append(parent.Replies, r)

     

       77
       +
       		}

     

       78
       +
       	}

     

       79
       +
       

     

       80
       +
       	var listing []CommentListItem

     

       81
       +
       	for _, v := range toplevel {

     

       82
       +
       		listing = append(listing, *v)

     

       83
       +
       	}

     

       84
       +
       

     

       85
       +
       	// sort everything

     

       86
       +
       	sortFunc := func(a, b *IssueComment) bool {

     

       87
       +
       		return a.Created.Before(b.Created)

     

       88
       +
       	}

     

       89
       +
       	sort.Slice(listing, func(i, j int) bool {

     

       90
       +
       		return sortFunc(listing[i].Self, listing[j].Self)

     

       91
       +
       	})

     

       92
       +
       	for _, r := range listing {

     

       93
       +
       		sort.Slice(r.Replies, func(i, j int) bool {

     

       94
       +
       			return sortFunc(r.Replies[i], r.Replies[j])

     

       95
       +
       		})

     

       96
       +
       	}

     

       97
       +
       

     

       98
       +
       	return listing

     

       99
       +
       }

     

       100
       +
       

     

       101
       +
       func (i *Issue) Participants() []string {

     

       102
       +
       	participantSet := make(map[string]struct{})

     

       103
       +
       	participants := []string{}

     

       104
       +
       

     

       105
       +
       	addParticipant := func(did string) {

     

       106
       +
       		if _, exists := participantSet[did]; !exists {

     

       107
       +
       			participantSet[did] = struct{}{}

     

       108
       +
       			participants = append(participants, did)

     

       109
       +
       		}

     

       110
       +
       	}

     

       111
       +
       

     

       112
       +
       	addParticipant(i.Did)

     

       113
       +
       

     

       114
       +
       	for _, c := range i.Comments {

     

       115
       +
       		addParticipant(c.Did)

     

       116
       +
       	}

     

       117
       +
       

     

       118
       +
       	return participants

     

       119
       +
       }

     

       120
       +
       

     

       121
       +
       func IssueFromRecord(did, rkey string, record tangled.RepoIssue) Issue {

     

       122
       +
       	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       123
       +
       	if err != nil {

     

       124
       +
       		created = time.Now()

     

       125
       +
       	}

     

       126
       +
       

     

       127
       +
       	body := ""

     

       128
       +
       	if record.Body != nil {

     

       129
       +
       		body = *record.Body

     

       130
       +
       	}

     

       131
       +
       

     

       132
       +
       	return Issue{

     

       133
       +
       		RepoAt:  syntax.ATURI(record.Repo),

     

       134
       +
       		Did:     did,

     

       135
       +
       		Rkey:    rkey,

     

       136
       +
       		Created: created,

     

       137
       +
       		Title:   record.Title,

     

       138
       +
       		Body:    body,

     

       139
       +
       		Open:    true, // new issues are open by default

     

       140
       +
       	}

     

       141
       +
       }

     

       142
       +
       

     

       143
       +
       type IssueComment struct {

     

       144
       +
       	Id      int64

     

       145
       +
       	Did     string

     

       146
       +
       	Rkey    string

     

       147
       +
       	IssueAt string

     

       148
       +
       	ReplyTo *string

     

       149
       +
       	Body    string

     

       150
       +
       	Created time.Time

     

       151
       +
       	Edited  *time.Time

     

       152
       +
       	Deleted *time.Time

     

       153
       +
       }

     

       154
       +
       

     

       155
       +
       func (i *IssueComment) AtUri() syntax.ATURI {

     

       156
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.Did, tangled.RepoIssueCommentNSID, i.Rkey))

     

       157
       +
       }

     

       158
       +
       

     

       159
       +
       func (i *IssueComment) AsRecord() tangled.RepoIssueComment {

     

       160
       +
       	return tangled.RepoIssueComment{

     

       161
       +
       		Body:      i.Body,

     

       162
       +
       		Issue:     i.IssueAt,

     

       163
       +
       		CreatedAt: i.Created.Format(time.RFC3339),

     

       164
       +
       		ReplyTo:   i.ReplyTo,

     

       165
       +
       	}

     

       166
       +
       }

     

       167
       +
       

     

       168
       +
       func (i *IssueComment) IsTopLevel() bool {

     

       169
       +
       	return i.ReplyTo == nil

     

       170
       +
       }

     

       171
       +
       

     

       172
       +
       func IssueCommentFromRecord(did, rkey string, record tangled.RepoIssueComment) (*IssueComment, error) {

     

       173
       +
       	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       174
       +
       	if err != nil {

     

       175
       +
       		created = time.Now()

     

       176
       +
       	}

     

       177
       +
       

     

       178
       +
       	ownerDid := did

     

       179
       +
       

     

       180
       +
       	if _, err = syntax.ParseATURI(record.Issue); err != nil {

     

       181
       +
       		return nil, err

     

       182
       +
       	}

     

       183
       +
       

     

       184
       +
       	comment := IssueComment{

     

       185
       +
       		Did:     ownerDid,

     

       186
       +
       		Rkey:    rkey,

     

       187
       +
       		Body:    record.Body,

     

       188
       +
       		IssueAt: record.Issue,

     

       189
       +
       		ReplyTo: record.ReplyTo,

     

       190
       +
       		Created: created,

     

       191
       +
       	}

     

       192
       +
       

     

       193
       +
       	return &comment, nil

     

       194
       +
       }

+14

appview/models/language.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       type RepoLanguage struct {

     

       8
       +
       	Id           int64

     

       9
       +
       	RepoAt       syntax.ATURI

     

       10
       +
       	Ref          string

     

       11
       +
       	IsDefaultRef bool

     

       12
       +
       	Language     string

     

       13
       +
       	Bytes        int64

     

       14
       +
       }

-173

appview/db/oauth.go

···

       1
       -
       package db

     

       2
       -
       

     

       3
       -
       type OAuthRequest struct {

     

       4
       -
       	ID                  uint

     

       5
       -
       	AuthserverIss       string

     

       6
       -
       	Handle              string

     

       7
       -
       	State               string

     

       8
       -
       	Did                 string

     

       9
       -
       	PdsUrl              string

     

       10
       -
       	PkceVerifier        string

     

       11
       -
       	DpopAuthserverNonce string

     

       12
       -
       	DpopPrivateJwk      string

     

       13
       -
       }

     

       14
       -
       

     

       15
       -
       func SaveOAuthRequest(e Execer, oauthRequest OAuthRequest) error {

     

       16
       -
       	_, err := e.Exec(`

     

       17
       -
       		insert into oauth_requests (

     

       18
       -
       			auth_server_iss,

     

       19
       -
       			state,

     

       20
       -
       			handle,

     

       21
       -
       			did,

     

       22
       -
       			pds_url,

     

       23
       -
       			pkce_verifier,

     

       24
       -
       			dpop_auth_server_nonce,

     

       25
       -
       			dpop_private_jwk

     

       26
       -
       		) values (?, ?, ?, ?, ?, ?, ?, ?)`,

     

       27
       -
       		oauthRequest.AuthserverIss,

     

       28
       -
       		oauthRequest.State,

     

       29
       -
       		oauthRequest.Handle,

     

       30
       -
       		oauthRequest.Did,

     

       31
       -
       		oauthRequest.PdsUrl,

     

       32
       -
       		oauthRequest.PkceVerifier,

     

       33
       -
       		oauthRequest.DpopAuthserverNonce,

     

       34
       -
       		oauthRequest.DpopPrivateJwk,

     

       35
       -
       	)

     

       36
       -
       	return err

     

       37
       -
       }

     

       38
       -
       

     

       39
       -
       func GetOAuthRequestByState(e Execer, state string) (OAuthRequest, error) {

     

       40
       -
       	var req OAuthRequest

     

       41
       -
       	err := e.QueryRow(`

     

       42
       -
       		select

     

       43
       -
       			id,

     

       44
       -
       			auth_server_iss,

     

       45
       -
       			handle,

     

       46
       -
       			state,

     

       47
       -
       			did,

     

       48
       -
       			pds_url,

     

       49
       -
       			pkce_verifier,

     

       50
       -
       			dpop_auth_server_nonce,

     

       51
       -
       			dpop_private_jwk

     

       52
       -
       		from oauth_requests

     

       53
       -
       		where state = ?`, state).Scan(

     

       54
       -
       		&req.ID,

     

       55
       -
       		&req.AuthserverIss,

     

       56
       -
       		&req.Handle,

     

       57
       -
       		&req.State,

     

       58
       -
       		&req.Did,

     

       59
       -
       		&req.PdsUrl,

     

       60
       -
       		&req.PkceVerifier,

     

       61
       -
       		&req.DpopAuthserverNonce,

     

       62
       -
       		&req.DpopPrivateJwk,

     

       63
       -
       	)

     

       64
       -
       	return req, err

     

       65
       -
       }

     

       66
       -
       

     

       67
       -
       func DeleteOAuthRequestByState(e Execer, state string) error {

     

       68
       -
       	_, err := e.Exec(`

     

       69
       -
       		delete from oauth_requests

     

       70
       -
       		where state = ?`, state)

     

       71
       -
       	return err

     

       72
       -
       }

     

       73
       -
       

     

       74
       -
       type OAuthSession struct {

     

       75
       -
       	ID                  uint

     

       76
       -
       	Handle              string

     

       77
       -
       	Did                 string

     

       78
       -
       	PdsUrl              string

     

       79
       -
       	AccessJwt           string

     

       80
       -
       	RefreshJwt          string

     

       81
       -
       	AuthServerIss       string

     

       82
       -
       	DpopPdsNonce        string

     

       83
       -
       	DpopAuthserverNonce string

     

       84
       -
       	DpopPrivateJwk      string

     

       85
       -
       	Expiry              string

     

       86
       -
       }

     

       87
       -
       

     

       88
       -
       func SaveOAuthSession(e Execer, session OAuthSession) error {

     

       89
       -
       	_, err := e.Exec(`

     

       90
       -
         insert into oauth_sessions (

     

       91
       -
          did,

     

       92
       -
          handle,

     

       93
       -
          pds_url,

     

       94
       -
          access_jwt,

     

       95
       -
          refresh_jwt,

     

       96
       -
          auth_server_iss,

     

       97
       -
          dpop_auth_server_nonce,

     

       98
       -
          dpop_private_jwk,

     

       99
       -
          expiry

     

       100
       -
         ) values (?, ?, ?, ?, ?, ?, ?, ?, ?)`,

     

       101
       -
       		session.Did,

     

       102
       -
       		session.Handle,

     

       103
       -
       		session.PdsUrl,

     

       104
       -
       		session.AccessJwt,

     

       105
       -
       		session.RefreshJwt,

     

       106
       -
       		session.AuthServerIss,

     

       107
       -
       		session.DpopAuthserverNonce,

     

       108
       -
       		session.DpopPrivateJwk,

     

       109
       -
       		session.Expiry,

     

       110
       -
       	)

     

       111
       -
       	return err

     

       112
       -
       }

     

       113
       -
       

     

       114
       -
       func RefreshOAuthSession(e Execer, did string, accessJwt, refreshJwt, expiry string) error {

     

       115
       -
       	_, err := e.Exec(`

     

       116
       -
         update oauth_sessions

     

       117
       -
         set access_jwt = ?, refresh_jwt = ?, expiry = ?

     

       118
       -
         where did = ?`,

     

       119
       -
       		accessJwt,

     

       120
       -
       		refreshJwt,

     

       121
       -
       		expiry,

     

       122
       -
       		did,

     

       123
       -
       	)

     

       124
       -
       	return err

     

       125
       -
       }

     

       126
       -
       

     

       127
       -
       func GetOAuthSessionByDid(e Execer, did string) (*OAuthSession, error) {

     

       128
       -
       	var session OAuthSession

     

       129
       -
       	err := e.QueryRow(`

     

       130
       -
         select

     

       131
       -
          id,

     

       132
       -
          did,

     

       133
       -
          handle,

     

       134
       -
          pds_url,

     

       135
       -
          access_jwt,

     

       136
       -
          refresh_jwt,

     

       137
       -
          auth_server_iss,

     

       138
       -
          dpop_auth_server_nonce,

     

       139
       -
          dpop_private_jwk,

     

       140
       -
          expiry

     

       141
       -
         from oauth_sessions

     

       142
       -
         where did = ?`, did).Scan(

     

       143
       -
       		&session.ID,

     

       144
       -
       		&session.Did,

     

       145
       -
       		&session.Handle,

     

       146
       -
       		&session.PdsUrl,

     

       147
       -
       		&session.AccessJwt,

     

       148
       -
       		&session.RefreshJwt,

     

       149
       -
       		&session.AuthServerIss,

     

       150
       -
       		&session.DpopAuthserverNonce,

     

       151
       -
       		&session.DpopPrivateJwk,

     

       152
       -
       		&session.Expiry,

     

       153
       -
       	)

     

       154
       -
       	return &session, err

     

       155
       -
       }

     

       156
       -
       

     

       157
       -
       func DeleteOAuthSessionByDid(e Execer, did string) error {

     

       158
       -
       	_, err := e.Exec(`

     

       159
       -
         delete from oauth_sessions

     

       160
       -
         where did = ?`, did)

     

       161
       -
       	return err

     

       162
       -
       }

     

       163
       -
       

     

       164
       -
       func UpdateDpopPdsNonce(e Execer, did string, dpopPdsNonce string) error {

     

       165
       -
       	_, err := e.Exec(`

     

       166
       -
         update oauth_sessions

     

       167
       -
         set dpop_pds_nonce = ?

     

       168
       -
         where did = ?`,

     

       169
       -
       		dpopPdsNonce,

     

       170
       -
       		did,

     

       171
       -
       	)

     

       172
       -
       	return err

     

       173
       -
       }

+177

appview/models/profile.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       	"tangled.org/core/api/tangled"

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       type Profile struct {

     

       11
       +
       	// ids

     

       12
       +
       	ID  int

     

       13
       +
       	Did string

     

       14
       +
       

     

       15
       +
       	// data

     

       16
       +
       	Description    string

     

       17
       +
       	IncludeBluesky bool

     

       18
       +
       	Location       string

     

       19
       +
       	Links          [5]string

     

       20
       +
       	Stats          [2]VanityStat

     

       21
       +
       	PinnedRepos    [6]syntax.ATURI

     

       22
       +
       }

     

       23
       +
       

     

       24
       +
       func (p Profile) IsLinksEmpty() bool {

     

       25
       +
       	for _, l := range p.Links {

     

       26
       +
       		if l != "" {

     

       27
       +
       			return false

     

       28
       +
       		}

     

       29
       +
       	}

     

       30
       +
       	return true

     

       31
       +
       }

     

       32
       +
       

     

       33
       +
       func (p Profile) IsStatsEmpty() bool {

     

       34
       +
       	for _, s := range p.Stats {

     

       35
       +
       		if s.Kind != "" {

     

       36
       +
       			return false

     

       37
       +
       		}

     

       38
       +
       	}

     

       39
       +
       	return true

     

       40
       +
       }

     

       41
       +
       

     

       42
       +
       func (p Profile) IsPinnedReposEmpty() bool {

     

       43
       +
       	for _, r := range p.PinnedRepos {

     

       44
       +
       		if r != "" {

     

       45
       +
       			return false

     

       46
       +
       		}

     

       47
       +
       	}

     

       48
       +
       	return true

     

       49
       +
       }

     

       50
       +
       

     

       51
       +
       type VanityStatKind string

     

       52
       +
       

     

       53
       +
       const (

     

       54
       +
       	VanityStatMergedPRCount    VanityStatKind = "merged-pull-request-count"

     

       55
       +
       	VanityStatClosedPRCount    VanityStatKind = "closed-pull-request-count"

     

       56
       +
       	VanityStatOpenPRCount      VanityStatKind = "open-pull-request-count"

     

       57
       +
       	VanityStatOpenIssueCount   VanityStatKind = "open-issue-count"

     

       58
       +
       	VanityStatClosedIssueCount VanityStatKind = "closed-issue-count"

     

       59
       +
       	VanityStatRepositoryCount  VanityStatKind = "repository-count"

     

       60
       +
       )

     

       61
       +
       

     

       62
       +
       func (v VanityStatKind) String() string {

     

       63
       +
       	switch v {

     

       64
       +
       	case VanityStatMergedPRCount:

     

       65
       +
       		return "Merged PRs"

     

       66
       +
       	case VanityStatClosedPRCount:

     

       67
       +
       		return "Closed PRs"

     

       68
       +
       	case VanityStatOpenPRCount:

     

       69
       +
       		return "Open PRs"

     

       70
       +
       	case VanityStatOpenIssueCount:

     

       71
       +
       		return "Open Issues"

     

       72
       +
       	case VanityStatClosedIssueCount:

     

       73
       +
       		return "Closed Issues"

     

       74
       +
       	case VanityStatRepositoryCount:

     

       75
       +
       		return "Repositories"

     

       76
       +
       	}

     

       77
       +
       	return ""

     

       78
       +
       }

     

       79
       +
       

     

       80
       +
       type VanityStat struct {

     

       81
       +
       	Kind  VanityStatKind

     

       82
       +
       	Value uint64

     

       83
       +
       }

     

       84
       +
       

     

       85
       +
       func (p *Profile) ProfileAt() syntax.ATURI {

     

       86
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", p.Did, tangled.ActorProfileNSID, "self"))

     

       87
       +
       }

     

       88
       +
       

     

       89
       +
       type RepoEvent struct {

     

       90
       +
       	Repo   *Repo

     

       91
       +
       	Source *Repo

     

       92
       +
       }

     

       93
       +
       

     

       94
       +
       type ProfileTimeline struct {

     

       95
       +
       	ByMonth []ByMonth

     

       96
       +
       }

     

       97
       +
       

     

       98
       +
       func (p *ProfileTimeline) IsEmpty() bool {

     

       99
       +
       	if p == nil {

     

       100
       +
       		return true

     

       101
       +
       	}

     

       102
       +
       

     

       103
       +
       	for _, m := range p.ByMonth {

     

       104
       +
       		if !m.IsEmpty() {

     

       105
       +
       			return false

     

       106
       +
       		}

     

       107
       +
       	}

     

       108
       +
       

     

       109
       +
       	return true

     

       110
       +
       }

     

       111
       +
       

     

       112
       +
       type ByMonth struct {

     

       113
       +
       	RepoEvents  []RepoEvent

     

       114
       +
       	IssueEvents IssueEvents

     

       115
       +
       	PullEvents  PullEvents

     

       116
       +
       }

     

       117
       +
       

     

       118
       +
       func (b ByMonth) IsEmpty() bool {

     

       119
       +
       	return len(b.RepoEvents) == 0 &&

     

       120
       +
       		len(b.IssueEvents.Items) == 0 &&

     

       121
       +
       		len(b.PullEvents.Items) == 0

     

       122
       +
       }

     

       123
       +
       

     

       124
       +
       type IssueEvents struct {

     

       125
       +
       	Items []*Issue

     

       126
       +
       }

     

       127
       +
       

     

       128
       +
       type IssueEventStats struct {

     

       129
       +
       	Open   int

     

       130
       +
       	Closed int

     

       131
       +
       }

     

       132
       +
       

     

       133
       +
       func (i IssueEvents) Stats() IssueEventStats {

     

       134
       +
       	var open, closed int

     

       135
       +
       	for _, issue := range i.Items {

     

       136
       +
       		if issue.Open {

     

       137
       +
       			open += 1

     

       138
       +
       		} else {

     

       139
       +
       			closed += 1

     

       140
       +
       		}

     

       141
       +
       	}

     

       142
       +
       

     

       143
       +
       	return IssueEventStats{

     

       144
       +
       		Open:   open,

     

       145
       +
       		Closed: closed,

     

       146
       +
       	}

     

       147
       +
       }

     

       148
       +
       

     

       149
       +
       type PullEvents struct {

     

       150
       +
       	Items []*Pull

     

       151
       +
       }

     

       152
       +
       

     

       153
       +
       func (p PullEvents) Stats() PullEventStats {

     

       154
       +
       	var open, merged, closed int

     

       155
       +
       	for _, pull := range p.Items {

     

       156
       +
       		switch pull.State {

     

       157
       +
       		case PullOpen:

     

       158
       +
       			open += 1

     

       159
       +
       		case PullMerged:

     

       160
       +
       			merged += 1

     

       161
       +
       		case PullClosed:

     

       162
       +
       			closed += 1

     

       163
       +
       		}

     

       164
       +
       	}

     

       165
       +
       

     

       166
       +
       	return PullEventStats{

     

       167
       +
       		Open:   open,

     

       168
       +
       		Merged: merged,

     

       169
       +
       		Closed: closed,

     

       170
       +
       	}

     

       171
       +
       }

     

       172
       +
       

     

       173
       +
       type PullEventStats struct {

     

       174
       +
       	Closed int

     

       175
       +
       	Open   int

     

       176
       +
       	Merged int

     

       177
       +
       }

+17 -139

appview/db/pipeline.go

···

       6
        
       	"strings"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       -
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       10
       -
       	"github.com/go-git/go-git/v5/plumbing"

     

       11
       -
       	spindle "tangled.org/core/spindle/models"

     

       12
       -
       	"tangled.org/core/workflow"

     

       13
        
       )

     

       14
        
       

     

       15
       -
       type Pipeline struct {

     

       16
       -
       	Id        int

     

       17
       -
       	Rkey      string

     

       18
       -
       	Knot      string

     

       19
       -
       	RepoOwner syntax.DID

     

       20
       -
       	RepoName  string

     

       21
       -
       	TriggerId int

     

       22
       -
       	Sha       string

     

       23
       -
       	Created   time.Time

     

       24
       -
       

     

       25
       -
       	// populate when querying for reverse mappings

     

       26
       -
       	Trigger  *Trigger

     

       27
       -
       	Statuses map[string]WorkflowStatus

     

       28
       -
       }

     

       29
       -
       

     

       30
       -
       type WorkflowStatus struct {

     

       31
       -
       	Data []PipelineStatus

     

       32
       -
       }

     

       33
       -
       

     

       34
       -
       func (w WorkflowStatus) Latest() PipelineStatus {

     

       35
       -
       	return w.Data[len(w.Data)-1]

     

       36
       -
       }

     

       37
       -
       

     

       38
       -
       // time taken by this workflow to reach an "end state"

     

       39
       -
       func (w WorkflowStatus) TimeTaken() time.Duration {

     

       40
       -
       	var start, end *time.Time

     

       41
       -
       	for _, s := range w.Data {

     

       42
       -
       		if s.Status.IsStart() {

     

       43
       -
       			start = &s.Created

     

       44
       -
       		}

     

       45
       -
       		if s.Status.IsFinish() {

     

       46
       -
       			end = &s.Created

     

       47
       -
       		}

     

       48
       -
       	}

     

       49
       -
       

     

       50
       -
       	if start != nil && end != nil && end.After(*start) {

     

       51
       -
       		return end.Sub(*start)

     

       52
       -
       	}

     

       53
       -
       

     

       54
       -
       	return 0

     

       55
       -
       }

     

       56
       -
       

     

       57
       -
       func (p Pipeline) Counts() map[string]int {

     

       58
       -
       	m := make(map[string]int)

     

       59
       -
       	for _, w := range p.Statuses {

     

       60
       -
       		m[w.Latest().Status.String()] += 1

     

       61
       -
       	}

     

       62
       -
       	return m

     

       63
       -
       }

     

       64
       -
       

     

       65
       -
       func (p Pipeline) TimeTaken() time.Duration {

     

       66
       -
       	var s time.Duration

     

       67
       -
       	for _, w := range p.Statuses {

     

       68
       -
       		s += w.TimeTaken()

     

       69
       -
       	}

     

       70
       -
       	return s

     

       71
       -
       }

     

       72
       -
       

     

       73
       -
       func (p Pipeline) Workflows() []string {

     

       74
       -
       	var ws []string

     

       75
       -
       	for v := range p.Statuses {

     

       76
       -
       		ws = append(ws, v)

     

       77
       -
       	}

     

       78
       -
       	slices.Sort(ws)

     

       79
       -
       	return ws

     

       80
       -
       }

     

       81
       -
       

     

       82
       -
       // if we know that a spindle has picked up this pipeline, then it is Responding

     

       83
       -
       func (p Pipeline) IsResponding() bool {

     

       84
       -
       	return len(p.Statuses) != 0

     

       85
       -
       }

     

       86
       -
       

     

       87
       -
       type Trigger struct {

     

       88
       -
       	Id   int

     

       89
       -
       	Kind workflow.TriggerKind

     

       90
       -
       

     

       91
       -
       	// push trigger fields

     

       92
       -
       	PushRef    *string

     

       93
       -
       	PushNewSha *string

     

       94
       -
       	PushOldSha *string

     

       95
       -
       

     

       96
       -
       	// pull request trigger fields

     

       97
       -
       	PRSourceBranch *string

     

       98
       -
       	PRTargetBranch *string

     

       99
       -
       	PRSourceSha    *string

     

       100
       -
       	PRAction       *string

     

       101
       -
       }

     

       102
       -
       

     

       103
       -
       func (t *Trigger) IsPush() bool {

     

       104
       -
       	return t != nil && t.Kind == workflow.TriggerKindPush

     

       105
       -
       }

     

       106
       -
       

     

       107
       -
       func (t *Trigger) IsPullRequest() bool {

     

       108
       -
       	return t != nil && t.Kind == workflow.TriggerKindPullRequest

     

       109
       -
       }

     

       110
       -
       

     

       111
       -
       func (t *Trigger) TargetRef() string {

     

       112
       -
       	if t.IsPush() {

     

       113
       -
       		return plumbing.ReferenceName(*t.PushRef).Short()

     

       114
       -
       	} else if t.IsPullRequest() {

     

       115
       -
       		return *t.PRTargetBranch

     

       116
       -
       	}

     

       117
       -
       

     

       118
       -
       	return ""

     

       119
       -
       }

     

       120
       -
       

     

       121
       -
       type PipelineStatus struct {

     

       122
       -
       	ID           int

     

       123
       -
       	Spindle      string

     

       124
       -
       	Rkey         string

     

       125
       -
       	PipelineKnot string

     

       126
       -
       	PipelineRkey string

     

       127
       -
       	Created      time.Time

     

       128
       -
       	Workflow     string

     

       129
       -
       	Status       spindle.StatusKind

     

       130
       -
       	Error        *string

     

       131
       -
       	ExitCode     int

     

       132
       -
       }

     

       133
       -
       

     

       134
       -
       func GetPipelines(e Execer, filters ...filter) ([]Pipeline, error) {

     

       135
       -
       	var pipelines []Pipeline

     

       136
        
       

     

       137
        
       	var conditions []string

     

       138
        
       	var args []any

     
···

       156
        
       	defer rows.Close()

     

       157
        
       

     

       158
        
       	for rows.Next() {

     

       159
       -
       		var pipeline Pipeline

     

       160
        
       		var createdAt string

     

       161
        
       		err = rows.Scan(

     

       162
        
       			&pipeline.Id,

     
···

       185
        
       	return pipelines, nil

     

       186
        
       }

     

       187
        
       

     

       188
       -
       func AddPipeline(e Execer, pipeline Pipeline) error {

     

       189
        
       	args := []any{

     

       190
        
       		pipeline.Rkey,

     

       191
        
       		pipeline.Knot,

     
···

       216
        
       	return err

     

       217
        
       }

     

       218
        
       

     

       219
       -
       func AddTrigger(e Execer, trigger Trigger) (int64, error) {

     

       220
        
       	args := []any{

     

       221
        
       		trigger.Kind,

     

       222
        
       		trigger.PushRef,

     
···

       252
        
       	return res.LastInsertId()

     

       253
        
       }

     

       254
        
       

     

       255
       -
       func AddPipelineStatus(e Execer, status PipelineStatus) error {

     

       256
        
       	args := []any{

     

       257
        
       		status.Spindle,

     

       258
        
       		status.Rkey,

     
···

       290
        
       

     

       291
        
       // this is a mega query, but the most useful one:

     

       292
        
       // get N pipelines, for each one get the latest status of its N workflows

     

       293
       -
       func GetPipelineStatuses(e Execer, filters ...filter) ([]Pipeline, error) {

     

       294
        
       	var conditions []string

     

       295
        
       	var args []any

     

       296
        
       	for _, filter := range filters {

     
···

       335
        
       	}

     

       336
        
       	defer rows.Close()

     

       337
        
       

     

       338
       -
       	pipelines := make(map[string]Pipeline)

     

       339
        
       	for rows.Next() {

     

       340
       -
       		var p Pipeline

     

       341
       -
       		var t Trigger

     

       342
        
       		var created string

     

       343
        
       

     

       344
        
       		err := rows.Scan(

     
···

       370
        
       

     

       371
        
       		t.Id = p.TriggerId

     

       372
        
       		p.Trigger = &t

     

       373
       -
       		p.Statuses = make(map[string]WorkflowStatus)

     

       374
        
       

     

       375
        
       		k := fmt.Sprintf("%s/%s", p.Knot, p.Rkey)

     

       376
        
       		pipelines[k] = p

     
···

       409
        
       	defer rows.Close()

     

       410
        
       

     

       411
        
       	for rows.Next() {

     

       412
       -
       		var ps PipelineStatus

     

       413
        
       		var created string

     

       414
        
       

     

       415
        
       		err := rows.Scan(

     
···

       442
        
       		}

     

       443
        
       		statuses, _ := pipeline.Statuses[ps.Workflow]

     

       444
        
       		if !ok {

     

       445
       -
       			pipeline.Statuses[ps.Workflow] = WorkflowStatus{}

     

       446
        
       		}

     

       447
        
       

     

       448
        
       		// append

     
···

       453
        
       		pipelines[key] = pipeline

     

       454
        
       	}

     

       455
        
       

     

       456
       -
       	var all []Pipeline

     

       457
        
       	for _, p := range pipelines {

     

       458
        
       		for _, s := range p.Statuses {

     

       459
       -
       			slices.SortFunc(s.Data, func(a, b PipelineStatus) int {

     

       460
        
       				if a.Created.After(b.Created) {

     

       461
        
       					return 1

     

       462
        
       				}

     
···

       476
        
       	}

     

       477
        
       

     

       478
        
       	// sort pipelines by date

     

       479
       -
       	slices.SortFunc(all, func(a, b Pipeline) int {

     

       480
        
       		if a.Created.After(b.Created) {

     

       481
        
       			return -1

     

       482
        
       		}

···

       6
        
       	"strings"

     

       7
        
       	"time"

     

       8
        
       

     

       9
       +
       	"tangled.org/core/appview/models"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       )

     

       11
        
       

     

       12
       +
       func GetPipelines(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       13
       +
       	var pipelines []models.Pipeline

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
       

     

       15
        
       	var conditions []string

     

       16
        
       	var args []any

     
···

       34
        
       	defer rows.Close()

     

       35
        
       

     

       36
        
       	for rows.Next() {

     

       37
       +
       		var pipeline models.Pipeline

     

       38
        
       		var createdAt string

     

       39
        
       		err = rows.Scan(

     

       40
        
       			&pipeline.Id,

     
···

       63
        
       	return pipelines, nil

     

       64
        
       }

     

       65
        
       

     

       66
       +
       func AddPipeline(e Execer, pipeline models.Pipeline) error {

     

       67
        
       	args := []any{

     

       68
        
       		pipeline.Rkey,

     

       69
        
       		pipeline.Knot,

     
···

       94
        
       	return err

     

       95
        
       }

     

       96
        
       

     

       97
       +
       func AddTrigger(e Execer, trigger models.Trigger) (int64, error) {

     

       98
        
       	args := []any{

     

       99
        
       		trigger.Kind,

     

       100
        
       		trigger.PushRef,

     
···

       130
        
       	return res.LastInsertId()

     

       131
        
       }

     

       132
        
       

     

       133
       +
       func AddPipelineStatus(e Execer, status models.PipelineStatus) error {

     

       134
        
       	args := []any{

     

       135
        
       		status.Spindle,

     

       136
        
       		status.Rkey,

     
···

       168
        
       

     

       169
        
       // this is a mega query, but the most useful one:

     

       170
        
       // get N pipelines, for each one get the latest status of its N workflows

     

       171
       +
       func GetPipelineStatuses(e Execer, filters ...filter) ([]models.Pipeline, error) {

     

       172
        
       	var conditions []string

     

       173
        
       	var args []any

     

       174
        
       	for _, filter := range filters {

     
···

       213
        
       	}

     

       214
        
       	defer rows.Close()

     

       215
        
       

     

       216
       +
       	pipelines := make(map[string]models.Pipeline)

     

       217
        
       	for rows.Next() {

     

       218
       +
       		var p models.Pipeline

     

       219
       +
       		var t models.Trigger

     

       220
        
       		var created string

     

       221
        
       

     

       222
        
       		err := rows.Scan(

     
···

       248
        
       

     

       249
        
       		t.Id = p.TriggerId

     

       250
        
       		p.Trigger = &t

     

       251
       +
       		p.Statuses = make(map[string]models.WorkflowStatus)

     

       252
        
       

     

       253
        
       		k := fmt.Sprintf("%s/%s", p.Knot, p.Rkey)

     

       254
        
       		pipelines[k] = p

     
···

       287
        
       	defer rows.Close()

     

       288
        
       

     

       289
        
       	for rows.Next() {

     

       290
       +
       		var ps models.PipelineStatus

     

       291
        
       		var created string

     

       292
        
       

     

       293
        
       		err := rows.Scan(

     
···

       320
        
       		}

     

       321
        
       		statuses, _ := pipeline.Statuses[ps.Workflow]

     

       322
        
       		if !ok {

     

       323
       +
       			pipeline.Statuses[ps.Workflow] = models.WorkflowStatus{}

     

       324
        
       		}

     

       325
        
       

     

       326
        
       		// append

     
···

       331
        
       		pipelines[key] = pipeline

     

       332
        
       	}

     

       333
        
       

     

       334
       +
       	var all []models.Pipeline

     

       335
        
       	for _, p := range pipelines {

     

       336
        
       		for _, s := range p.Statuses {

     

       337
       +
       			slices.SortFunc(s.Data, func(a, b models.PipelineStatus) int {

     

       338
        
       				if a.Created.After(b.Created) {

     

       339
        
       					return 1

     

       340
        
       				}

     
···

       354
        
       	}

     

       355
        
       

     

       356
        
       	// sort pipelines by date

     

       357
       +
       	slices.SortFunc(all, func(a, b models.Pipeline) int {

     

       358
        
       		if a.Created.After(b.Created) {

     

       359
        
       			return -1

     

       360
        
       		}

+130

appview/models/pipeline.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"slices"

     

       5
       +
       	"time"

     

       6
       +
       

     

       7
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       +
       	spindle "tangled.org/core/spindle/models"

     

       10
       +
       	"tangled.org/core/workflow"

     

       11
       +
       )

     

       12
       +
       

     

       13
       +
       type Pipeline struct {

     

       14
       +
       	Id        int

     

       15
       +
       	Rkey      string

     

       16
       +
       	Knot      string

     

       17
       +
       	RepoOwner syntax.DID

     

       18
       +
       	RepoName  string

     

       19
       +
       	TriggerId int

     

       20
       +
       	Sha       string

     

       21
       +
       	Created   time.Time

     

       22
       +
       

     

       23
       +
       	// populate when querying for reverse mappings

     

       24
       +
       	Trigger  *Trigger

     

       25
       +
       	Statuses map[string]WorkflowStatus

     

       26
       +
       }

     

       27
       +
       

     

       28
       +
       type WorkflowStatus struct {

     

       29
       +
       	Data []PipelineStatus

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       func (w WorkflowStatus) Latest() PipelineStatus {

     

       33
       +
       	return w.Data[len(w.Data)-1]

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       // time taken by this workflow to reach an "end state"

     

       37
       +
       func (w WorkflowStatus) TimeTaken() time.Duration {

     

       38
       +
       	var start, end *time.Time

     

       39
       +
       	for _, s := range w.Data {

     

       40
       +
       		if s.Status.IsStart() {

     

       41
       +
       			start = &s.Created

     

       42
       +
       		}

     

       43
       +
       		if s.Status.IsFinish() {

     

       44
       +
       			end = &s.Created

     

       45
       +
       		}

     

       46
       +
       	}

     

       47
       +
       

     

       48
       +
       	if start != nil && end != nil && end.After(*start) {

     

       49
       +
       		return end.Sub(*start)

     

       50
       +
       	}

     

       51
       +
       

     

       52
       +
       	return 0

     

       53
       +
       }

     

       54
       +
       

     

       55
       +
       func (p Pipeline) Counts() map[string]int {

     

       56
       +
       	m := make(map[string]int)

     

       57
       +
       	for _, w := range p.Statuses {

     

       58
       +
       		m[w.Latest().Status.String()] += 1

     

       59
       +
       	}

     

       60
       +
       	return m

     

       61
       +
       }

     

       62
       +
       

     

       63
       +
       func (p Pipeline) TimeTaken() time.Duration {

     

       64
       +
       	var s time.Duration

     

       65
       +
       	for _, w := range p.Statuses {

     

       66
       +
       		s += w.TimeTaken()

     

       67
       +
       	}

     

       68
       +
       	return s

     

       69
       +
       }

     

       70
       +
       

     

       71
       +
       func (p Pipeline) Workflows() []string {

     

       72
       +
       	var ws []string

     

       73
       +
       	for v := range p.Statuses {

     

       74
       +
       		ws = append(ws, v)

     

       75
       +
       	}

     

       76
       +
       	slices.Sort(ws)

     

       77
       +
       	return ws

     

       78
       +
       }

     

       79
       +
       

     

       80
       +
       // if we know that a spindle has picked up this pipeline, then it is Responding

     

       81
       +
       func (p Pipeline) IsResponding() bool {

     

       82
       +
       	return len(p.Statuses) != 0

     

       83
       +
       }

     

       84
       +
       

     

       85
       +
       type Trigger struct {

     

       86
       +
       	Id   int

     

       87
       +
       	Kind workflow.TriggerKind

     

       88
       +
       

     

       89
       +
       	// push trigger fields

     

       90
       +
       	PushRef    *string

     

       91
       +
       	PushNewSha *string

     

       92
       +
       	PushOldSha *string

     

       93
       +
       

     

       94
       +
       	// pull request trigger fields

     

       95
       +
       	PRSourceBranch *string

     

       96
       +
       	PRTargetBranch *string

     

       97
       +
       	PRSourceSha    *string

     

       98
       +
       	PRAction       *string

     

       99
       +
       }

     

       100
       +
       

     

       101
       +
       func (t *Trigger) IsPush() bool {

     

       102
       +
       	return t != nil && t.Kind == workflow.TriggerKindPush

     

       103
       +
       }

     

       104
       +
       

     

       105
       +
       func (t *Trigger) IsPullRequest() bool {

     

       106
       +
       	return t != nil && t.Kind == workflow.TriggerKindPullRequest

     

       107
       +
       }

     

       108
       +
       

     

       109
       +
       func (t *Trigger) TargetRef() string {

     

       110
       +
       	if t.IsPush() {

     

       111
       +
       		return plumbing.ReferenceName(*t.PushRef).Short()

     

       112
       +
       	} else if t.IsPullRequest() {

     

       113
       +
       		return *t.PRTargetBranch

     

       114
       +
       	}

     

       115
       +
       

     

       116
       +
       	return ""

     

       117
       +
       }

     

       118
       +
       

     

       119
       +
       type PipelineStatus struct {

     

       120
       +
       	ID           int

     

       121
       +
       	Spindle      string

     

       122
       +
       	Rkey         string

     

       123
       +
       	PipelineKnot string

     

       124
       +
       	PipelineRkey string

     

       125
       +
       	Created      time.Time

     

       126
       +
       	Workflow     string

     

       127
       +
       	Status       spindle.StatusKind

     

       128
       +
       	Error        *string

     

       129
       +
       	ExitCode     int

     

       130
       +
       }

+25

appview/models/pubkey.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"encoding/json"

     

       5
       +
       	"time"

     

       6
       +
       )

     

       7
       +
       

     

       8
       +
       type PublicKey struct {

     

       9
       +
       	Did     string `json:"did"`

     

       10
       +
       	Key     string `json:"key"`

     

       11
       +
       	Name    string `json:"name"`

     

       12
       +
       	Rkey    string `json:"rkey"`

     

       13
       +
       	Created *time.Time

     

       14
       +
       }

     

       15
       +
       

     

       16
       +
       func (p PublicKey) MarshalJSON() ([]byte, error) {

     

       17
       +
       	type Alias PublicKey

     

       18
       +
       	return json.Marshal(&struct {

     

       19
       +
       		Created string `json:"created"`

     

       20
       +
       		*Alias

     

       21
       +
       	}{

     

       22
       +
       		Created: p.Created.Format(time.RFC3339),

     

       23
       +
       		Alias:   (*Alias)(&p),

     

       24
       +
       	})

     

       25
       +
       }

+14

appview/models/punchcard.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import "time"

     

       4
       +
       

     

       5
       +
       type Punch struct {

     

       6
       +
       	Did   string

     

       7
       +
       	Date  time.Time

     

       8
       +
       	Count int

     

       9
       +
       }

     

       10
       +
       

     

       11
       +
       type Punchcard struct {

     

       12
       +
       	Total   int

     

       13
       +
       	Punches []Punch

     

       14
       +
       }

+44

appview/models/registration.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import "time"

     

       4
       +
       

     

       5
       +
       // Registration represents a knot registration. Knot would've been a better

     

       6
       +
       // name but we're stuck with this for historical reasons.

     

       7
       +
       type Registration struct {

     

       8
       +
       	Id           int64

     

       9
       +
       	Domain       string

     

       10
       +
       	ByDid        string

     

       11
       +
       	Created      *time.Time

     

       12
       +
       	Registered   *time.Time

     

       13
       +
       	NeedsUpgrade bool

     

       14
       +
       }

     

       15
       +
       

     

       16
       +
       func (r *Registration) Status() Status {

     

       17
       +
       	if r.NeedsUpgrade {

     

       18
       +
       		return NeedsUpgrade

     

       19
       +
       	} else if r.Registered != nil {

     

       20
       +
       		return Registered

     

       21
       +
       	} else {

     

       22
       +
       		return Pending

     

       23
       +
       	}

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       func (r *Registration) IsRegistered() bool {

     

       27
       +
       	return r.Status() == Registered

     

       28
       +
       }

     

       29
       +
       

     

       30
       +
       func (r *Registration) IsNeedsUpgrade() bool {

     

       31
       +
       	return r.Status() == NeedsUpgrade

     

       32
       +
       }

     

       33
       +
       

     

       34
       +
       func (r *Registration) IsPending() bool {

     

       35
       +
       	return r.Status() == Pending

     

       36
       +
       }

     

       37
       +
       

     

       38
       +
       type Status uint32

     

       39
       +
       

     

       40
       +
       const (

     

       41
       +
       	Registered Status = iota

     

       42
       +
       	Pending

     

       43
       +
       	NeedsUpgrade

     

       44
       +
       )

+14 -63

appview/db/reaction.go

···

       5
        
       	"time"

     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       0
        
       
     

       8
        
       )

     

       9
        
       

     

       10
       -
       type ReactionKind string

     

       11
       -
       

     

       12
       -
       const (

     

       13
       -
       	Like        ReactionKind = "👍"

     

       14
       -
       	Unlike      ReactionKind = "👎"

     

       15
       -
       	Laugh       ReactionKind = "😆"

     

       16
       -
       	Celebration ReactionKind = "🎉"

     

       17
       -
       	Confused    ReactionKind = "🫤"

     

       18
       -
       	Heart       ReactionKind = "❤️"

     

       19
       -
       	Rocket      ReactionKind = "🚀"

     

       20
       -
       	Eyes        ReactionKind = "👀"

     

       21
       -
       )

     

       22
       -
       

     

       23
       -
       func (rk ReactionKind) String() string {

     

       24
       -
       	return string(rk)

     

       25
       -
       }

     

       26
       -
       

     

       27
       -
       var OrderedReactionKinds = []ReactionKind{

     

       28
       -
       	Like,

     

       29
       -
       	Unlike,

     

       30
       -
       	Laugh,

     

       31
       -
       	Celebration,

     

       32
       -
       	Confused,

     

       33
       -
       	Heart,

     

       34
       -
       	Rocket,

     

       35
       -
       	Eyes,

     

       36
       -
       }

     

       37
       -
       

     

       38
       -
       func ParseReactionKind(raw string) (ReactionKind, bool) {

     

       39
       -
       	k, ok := (map[string]ReactionKind{

     

       40
       -
       		"👍":  Like,

     

       41
       -
       		"👎":  Unlike,

     

       42
       -
       		"😆":  Laugh,

     

       43
       -
       		"🎉":  Celebration,

     

       44
       -
       		"🫤":  Confused,

     

       45
       -
       		"❤️": Heart,

     

       46
       -
       		"🚀":  Rocket,

     

       47
       -
       		"👀":  Eyes,

     

       48
       -
       	})[raw]

     

       49
       -
       	return k, ok

     

       50
       -
       }

     

       51
       -
       

     

       52
       -
       type Reaction struct {

     

       53
       -
       	ReactedByDid string

     

       54
       -
       	ThreadAt     syntax.ATURI

     

       55
       -
       	Created      time.Time

     

       56
       -
       	Rkey         string

     

       57
       -
       	Kind         ReactionKind

     

       58
       -
       }

     

       59
       -
       

     

       60
       -
       func AddReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind, rkey string) error {

     

       61
        
       	query := `insert or ignore into reactions (reacted_by_did, thread_at, kind, rkey) values (?, ?, ?, ?)`

     

       62
        
       	_, err := e.Exec(query, reactedByDid, threadAt, kind, rkey)

     

       63
        
       	return err

     

       64
        
       }

     

       65
        
       

     

       66
        
       // Get a reaction record

     

       67
       -
       func GetReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind) (*Reaction, error) {

     

       68
        
       	query := `

     

       69
        
       	select reacted_by_did, thread_at, created, rkey

     

       70
        
       	from reactions

     

       71
        
       	where reacted_by_did = ? and thread_at = ? and kind = ?`

     

       72
        
       	row := e.QueryRow(query, reactedByDid, threadAt, kind)

     

       73
        
       

     

       74
       -
       	var reaction Reaction

     

       75
        
       	var created string

     

       76
        
       	err := row.Scan(&reaction.ReactedByDid, &reaction.ThreadAt, &created, &reaction.Rkey)

     

       77
        
       	if err != nil {

     
···

       90
        
       }

     

       91
        
       

     

       92
        
       // Remove a reaction

     

       93
       -
       func DeleteReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind) error {

     

       94
        
       	_, err := e.Exec(`delete from reactions where reacted_by_did = ? and thread_at = ? and kind = ?`, reactedByDid, threadAt, kind)

     

       95
        
       	return err

     

       96
        
       }

     
···

       101
        
       	return err

     

       102
        
       }

     

       103
        
       

     

       104
       -
       func GetReactionCount(e Execer, threadAt syntax.ATURI, kind ReactionKind) (int, error) {

     

       105
        
       	count := 0

     

       106
        
       	err := e.QueryRow(

     

       107
        
       		`select count(reacted_by_did) from reactions where thread_at = ? and kind = ?`, threadAt, kind).Scan(&count)

     
···

       111
        
       	return count, nil

     

       112
        
       }

     

       113
        
       

     

       114
       -
       func GetReactionCountMap(e Execer, threadAt syntax.ATURI) (map[ReactionKind]int, error) {

     

       115
       -
       	countMap := map[ReactionKind]int{}

     

       116
       -
       	for _, kind := range OrderedReactionKinds {

     

       117
        
       		count, err := GetReactionCount(e, threadAt, kind)

     

       118
        
       		if err != nil {

     

       119
       -
       			return map[ReactionKind]int{}, nil

     

       120
        
       		}

     

       121
        
       		countMap[kind] = count

     

       122
        
       	}

     

       123
        
       	return countMap, nil

     

       124
        
       }

     

       125
        
       

     

       126
       -
       func GetReactionStatus(e Execer, userDid string, threadAt syntax.ATURI, kind ReactionKind) bool {

     

       127
        
       	if _, err := GetReaction(e, userDid, threadAt, kind); err != nil {

     

       128
        
       		return false

     

       129
        
       	} else {

     
···

       131
        
       	}

     

       132
        
       }

     

       133
        
       

     

       134
       -
       func GetReactionStatusMap(e Execer, userDid string, threadAt syntax.ATURI) map[ReactionKind]bool {

     

       135
       -
       	statusMap := map[ReactionKind]bool{}

     

       136
       -
       	for _, kind := range OrderedReactionKinds {

     

       137
        
       		count := GetReactionStatus(e, userDid, threadAt, kind)

     

       138
        
       		statusMap[kind] = count

     

       139
        
       	}

···

       5
        
       	"time"

     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
       +
       	"tangled.org/core/appview/models"

     

       9
        
       )

     

       10
        
       

     

       11
       +
       func AddReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind models.ReactionKind, rkey string) error {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       	query := `insert or ignore into reactions (reacted_by_did, thread_at, kind, rkey) values (?, ?, ?, ?)`

     

       13
        
       	_, err := e.Exec(query, reactedByDid, threadAt, kind, rkey)

     

       14
        
       	return err

     

       15
        
       }

     

       16
        
       

     

       17
        
       // Get a reaction record

     

       18
       +
       func GetReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind models.ReactionKind) (*models.Reaction, error) {

     

       19
        
       	query := `

     

       20
        
       	select reacted_by_did, thread_at, created, rkey

     

       21
        
       	from reactions

     

       22
        
       	where reacted_by_did = ? and thread_at = ? and kind = ?`

     

       23
        
       	row := e.QueryRow(query, reactedByDid, threadAt, kind)

     

       24
        
       

     

       25
       +
       	var reaction models.Reaction

     

       26
        
       	var created string

     

       27
        
       	err := row.Scan(&reaction.ReactedByDid, &reaction.ThreadAt, &created, &reaction.Rkey)

     

       28
        
       	if err != nil {

     
···

       41
        
       }

     

       42
        
       

     

       43
        
       // Remove a reaction

     

       44
       +
       func DeleteReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind models.ReactionKind) error {

     

       45
        
       	_, err := e.Exec(`delete from reactions where reacted_by_did = ? and thread_at = ? and kind = ?`, reactedByDid, threadAt, kind)

     

       46
        
       	return err

     

       47
        
       }

     
···

       52
        
       	return err

     

       53
        
       }

     

       54
        
       

     

       55
       +
       func GetReactionCount(e Execer, threadAt syntax.ATURI, kind models.ReactionKind) (int, error) {

     

       56
        
       	count := 0

     

       57
        
       	err := e.QueryRow(

     

       58
        
       		`select count(reacted_by_did) from reactions where thread_at = ? and kind = ?`, threadAt, kind).Scan(&count)

     
···

       62
        
       	return count, nil

     

       63
        
       }

     

       64
        
       

     

       65
       +
       func GetReactionCountMap(e Execer, threadAt syntax.ATURI) (map[models.ReactionKind]int, error) {

     

       66
       +
       	countMap := map[models.ReactionKind]int{}

     

       67
       +
       	for _, kind := range models.OrderedReactionKinds {

     

       68
        
       		count, err := GetReactionCount(e, threadAt, kind)

     

       69
        
       		if err != nil {

     

       70
       +
       			return map[models.ReactionKind]int{}, nil

     

       71
        
       		}

     

       72
        
       		countMap[kind] = count

     

       73
        
       	}

     

       74
        
       	return countMap, nil

     

       75
        
       }

     

       76
        
       

     

       77
       +
       func GetReactionStatus(e Execer, userDid string, threadAt syntax.ATURI, kind models.ReactionKind) bool {

     

       78
        
       	if _, err := GetReaction(e, userDid, threadAt, kind); err != nil {

     

       79
        
       		return false

     

       80
        
       	} else {

     
···

       82
        
       	}

     

       83
        
       }

     

       84
        
       

     

       85
       +
       func GetReactionStatusMap(e Execer, userDid string, threadAt syntax.ATURI) map[models.ReactionKind]bool {

     

       86
       +
       	statusMap := map[models.ReactionKind]bool{}

     

       87
       +
       	for _, kind := range models.OrderedReactionKinds {

     

       88
        
       		count := GetReactionStatus(e, userDid, threadAt, kind)

     

       89
        
       		statusMap[kind] = count

     

       90
        
       	}

+57

appview/models/reaction.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type ReactionKind string

     

       10
       +
       

     

       11
       +
       const (

     

       12
       +
       	Like        ReactionKind = "👍"

     

       13
       +
       	Unlike      ReactionKind = "👎"

     

       14
       +
       	Laugh       ReactionKind = "😆"

     

       15
       +
       	Celebration ReactionKind = "🎉"

     

       16
       +
       	Confused    ReactionKind = "🫤"

     

       17
       +
       	Heart       ReactionKind = "❤️"

     

       18
       +
       	Rocket      ReactionKind = "🚀"

     

       19
       +
       	Eyes        ReactionKind = "👀"

     

       20
       +
       )

     

       21
       +
       

     

       22
       +
       func (rk ReactionKind) String() string {

     

       23
       +
       	return string(rk)

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       var OrderedReactionKinds = []ReactionKind{

     

       27
       +
       	Like,

     

       28
       +
       	Unlike,

     

       29
       +
       	Laugh,

     

       30
       +
       	Celebration,

     

       31
       +
       	Confused,

     

       32
       +
       	Heart,

     

       33
       +
       	Rocket,

     

       34
       +
       	Eyes,

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       func ParseReactionKind(raw string) (ReactionKind, bool) {

     

       38
       +
       	k, ok := (map[string]ReactionKind{

     

       39
       +
       		"👍":  Like,

     

       40
       +
       		"👎":  Unlike,

     

       41
       +
       		"😆":  Laugh,

     

       42
       +
       		"🎉":  Celebration,

     

       43
       +
       		"🫤":  Confused,

     

       44
       +
       		"❤️": Heart,

     

       45
       +
       		"🚀":  Rocket,

     

       46
       +
       		"👀":  Eyes,

     

       47
       +
       	})[raw]

     

       48
       +
       	return k, ok

     

       49
       +
       }

     

       50
       +
       

     

       51
       +
       type Reaction struct {

     

       52
       +
       	ReactedByDid string

     

       53
       +
       	ThreadAt     syntax.ATURI

     

       54
       +
       	Created      time.Time

     

       55
       +
       	Rkey         string

     

       56
       +
       	Kind         ReactionKind

     

       57
       +
       }

+10

appview/models/signup.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import "time"

     

       4
       +
       

     

       5
       +
       type InflightSignup struct {

     

       6
       +
       	Id         int64

     

       7
       +
       	Email      string

     

       8
       +
       	InviteCode string

     

       9
       +
       	Created    time.Time

     

       10
       +
       }

+25

appview/models/spindle.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type Spindle struct {

     

       10
       +
       	Id           int

     

       11
       +
       	Owner        syntax.DID

     

       12
       +
       	Instance     string

     

       13
       +
       	Verified     *time.Time

     

       14
       +
       	Created      time.Time

     

       15
       +
       	NeedsUpgrade bool

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       type SpindleMember struct {

     

       19
       +
       	Id       int

     

       20
       +
       	Did      syntax.DID // owner of the record

     

       21
       +
       	Rkey     string     // rkey of the record

     

       22
       +
       	Instance string

     

       23
       +
       	Subject  syntax.DID // the member being added

     

       24
       +
       	Created  time.Time

     

       25
       +
       }

+17

appview/models/star.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"time"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type Star struct {

     

       10
       +
       	StarredByDid string

     

       11
       +
       	RepoAt       syntax.ATURI

     

       12
       +
       	Created      time.Time

     

       13
       +
       	Rkey         string

     

       14
       +
       

     

       15
       +
       	// optionally, populate this when querying for reverse mappings

     

       16
       +
       	Repo *Repo

     

       17
       +
       }

+1 -1

appview/state/star.go

···

       56
        
       		}

     

       57
        
       		log.Println("created atproto record: ", resp.Uri)

     

       58
        
       

     

       59
       -
       		star := &db.Star{

     

       60
        
       			StarredByDid: currentUser.Did,

     

       61
        
       			RepoAt:       subjectUri,

     

       62
        
       			Rkey:         rkey,

···

       56
        
       		}

     

       57
        
       		log.Println("created atproto record: ", resp.Uri)

     

       58
        
       

     

       59
       +
       		star := &models.Star{

     

       60
        
       			StarredByDid: currentUser.Did,

     

       61
        
       			RepoAt:       subjectUri,

     

       62
        
       			Rkey:         rkey,

+95

appview/models/string.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"bytes"

     

       5
       +
       	"fmt"

     

       6
       +
       	"io"

     

       7
       +
       	"strings"

     

       8
       +
       	"time"

     

       9
       +
       

     

       10
       +
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       11
       +
       	"tangled.org/core/api/tangled"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       type String struct {

     

       15
       +
       	Did  syntax.DID

     

       16
       +
       	Rkey string

     

       17
       +
       

     

       18
       +
       	Filename    string

     

       19
       +
       	Description string

     

       20
       +
       	Contents    string

     

       21
       +
       	Created     time.Time

     

       22
       +
       	Edited      *time.Time

     

       23
       +
       }

     

       24
       +
       

     

       25
       +
       func (s *String) StringAt() syntax.ATURI {

     

       26
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", s.Did, tangled.StringNSID, s.Rkey))

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       func (s *String) AsRecord() tangled.String {

     

       30
       +
       	return tangled.String{

     

       31
       +
       		Filename:    s.Filename,

     

       32
       +
       		Description: s.Description,

     

       33
       +
       		Contents:    s.Contents,

     

       34
       +
       		CreatedAt:   s.Created.Format(time.RFC3339),

     

       35
       +
       	}

     

       36
       +
       }

     

       37
       +
       

     

       38
       +
       func StringFromRecord(did, rkey string, record tangled.String) String {

     

       39
       +
       	created, err := time.Parse(record.CreatedAt, time.RFC3339)

     

       40
       +
       	if err != nil {

     

       41
       +
       		created = time.Now()

     

       42
       +
       	}

     

       43
       +
       	return String{

     

       44
       +
       		Did:         syntax.DID(did),

     

       45
       +
       		Rkey:        rkey,

     

       46
       +
       		Filename:    record.Filename,

     

       47
       +
       		Description: record.Description,

     

       48
       +
       		Contents:    record.Contents,

     

       49
       +
       		Created:     created,

     

       50
       +
       	}

     

       51
       +
       }

     

       52
       +
       

     

       53
       +
       type StringStats struct {

     

       54
       +
       	LineCount uint64

     

       55
       +
       	ByteCount uint64

     

       56
       +
       }

     

       57
       +
       

     

       58
       +
       func (s String) Stats() StringStats {

     

       59
       +
       	lineCount, err := countLines(strings.NewReader(s.Contents))

     

       60
       +
       	if err != nil {

     

       61
       +
       		// non-fatal

     

       62
       +
       		// TODO: log this?

     

       63
       +
       	}

     

       64
       +
       

     

       65
       +
       	return StringStats{

     

       66
       +
       		LineCount: uint64(lineCount),

     

       67
       +
       		ByteCount: uint64(len(s.Contents)),

     

       68
       +
       	}

     

       69
       +
       }

     

       70
       +
       

     

       71
       +
       func countLines(r io.Reader) (int, error) {

     

       72
       +
       	buf := make([]byte, 32*1024)

     

       73
       +
       	bufLen := 0

     

       74
       +
       	count := 0

     

       75
       +
       	nl := []byte{'\n'}

     

       76
       +
       

     

       77
       +
       	for {

     

       78
       +
       		c, err := r.Read(buf)

     

       79
       +
       		if c > 0 {

     

       80
       +
       			bufLen += c

     

       81
       +
       		}

     

       82
       +
       		count += bytes.Count(buf[:c], nl)

     

       83
       +
       

     

       84
       +
       		switch {

     

       85
       +
       		case err == io.EOF:

     

       86
       +
       			/* handle last line not having a newline at the end */

     

       87
       +
       			if bufLen >= 1 && buf[(bufLen-1)%(32*1024)] != '\n' {

     

       88
       +
       				count++

     

       89
       +
       			}

     

       90
       +
       			return count, nil

     

       91
       +
       		case err != nil:

     

       92
       +
       			return 0, err

     

       93
       +
       		}

     

       94
       +
       	}

     

       95
       +
       }

+3 -2

appview/strings/strings.go

···

       11
        
       	"tangled.org/core/api/tangled"

     

       12
        
       	"tangled.org/core/appview/db"

     

       13
        
       	"tangled.org/core/appview/middleware"

     

       0
        
       
     

       14
        
       	"tangled.org/core/appview/notify"

     

       15
        
       	"tangled.org/core/appview/oauth"

     

       16
        
       	"tangled.org/core/appview/pages"

     
···

       235
        
       		description := r.FormValue("description")

     

       236
        
       

     

       237
        
       		// construct new string from form values

     

       238
       -
       		entry := db.String{

     

       239
        
       			Did:         first.Did,

     

       240
        
       			Rkey:        first.Rkey,

     

       241
        
       			Filename:    filename,

     
···

       318
        
       

     

       319
        
       		description := r.FormValue("description")

     

       320
        
       

     

       321
       -
       		string := db.String{

     

       322
        
       			Did:         syntax.DID(user.Did),

     

       323
        
       			Rkey:        tid.TID(),

     

       324
        
       			Filename:    filename,

···

       11
        
       	"tangled.org/core/api/tangled"

     

       12
        
       	"tangled.org/core/appview/db"

     

       13
        
       	"tangled.org/core/appview/middleware"

     

       14
       +
       	"tangled.org/core/appview/models"

     

       15
        
       	"tangled.org/core/appview/notify"

     

       16
        
       	"tangled.org/core/appview/oauth"

     

       17
        
       	"tangled.org/core/appview/pages"

     
···

       236
        
       		description := r.FormValue("description")

     

       237
        
       

     

       238
        
       		// construct new string from form values

     

       239
       +
       		entry := models.String{

     

       240
        
       			Did:         first.Did,

     

       241
        
       			Rkey:        first.Rkey,

     

       242
        
       			Filename:    filename,

     
···

       319
        
       

     

       320
        
       		description := r.FormValue("description")

     

       321
        
       

     

       322
       +
       		string := models.String{

     

       323
        
       			Did:         syntax.DID(user.Did),

     

       324
        
       			Rkey:        tid.TID(),

     

       325
        
       			Filename:    filename,

+27

appview/validator/string.go

···

       1
       +
       package validator

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"errors"

     

       5
       +
       	"fmt"

     

       6
       +
       	"unicode/utf8"

     

       7
       +
       

     

       8
       +
       	"tangled.org/core/appview/models"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       func (v *Validator) ValidateString(s *models.String) error {

     

       12
       +
       	var err error

     

       13
       +
       

     

       14
       +
       	if utf8.RuneCountInString(s.Filename) > 140 {

     

       15
       +
       		err = errors.Join(err, fmt.Errorf("filename too long"))

     

       16
       +
       	}

     

       17
       +
       

     

       18
       +
       	if utf8.RuneCountInString(s.Description) > 280 {

     

       19
       +
       		err = errors.Join(err, fmt.Errorf("description too long"))

     

       20
       +
       	}

     

       21
       +
       

     

       22
       +
       	if len(s.Contents) == 0 {

     

       23
       +
       		err = errors.Join(err, fmt.Errorf("contents is empty"))

     

       24
       +
       	}

     

       25
       +
       

     

       26
       +
       	return err

     

       27
       +
       }

+11 -32

appview/db/timeline.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"sort"

     

       5
       -
       	"time"

     

       6
        
       

     

       7
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       8
        
       	"tangled.org/core/appview/models"

     

       9
        
       )

     

       10
        
       

     

       11
       -
       type TimelineEvent struct {

     

       12
       -
       	*models.Repo

     

       13
       -
       	*models.Follow

     

       14
       -
       	*models.Star

     

       15
       -
       

     

       16
       -
       	EventAt time.Time

     

       17
       -
       

     

       18
       -
       	// optional: populate only if Repo is a fork

     

       19
       -
       	Source *models.Repo

     

       20
       -
       

     

       21
       -
       	// optional: populate only if event is Follow

     

       22
       -
       	*models.Profile

     

       23
       -
       	*models.FollowStats

     

       24
       -
       	*models.FollowStatus

     

       25
       -
       

     

       26
       -
       	// optional: populate only if event is Repo

     

       27
       -
       	IsStarred bool

     

       28
       -
       	StarCount int64

     

       29
       -
       }

     

       30
       -
       

     

       31
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     

       32
        
       // them in code; if we did this entirely in sql, we could order and limit and paginate easily

     

       33
       -
       func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       34
       -
       	var events []TimelineEvent

     

       35
        
       

     

       36
        
       	repos, err := getTimelineRepos(e, limit, loggedInUserDid)

     

       37
        
       	if err != nil {

     
···

       91
        
       	return isStarred, starCount

     

       92
        
       }

     

       93
        
       

     

       94
       -
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       95
        
       	repos, err := GetRepos(e, limit)

     

       96
        
       	if err != nil {

     

       97
        
       		return nil, err

     
···

       123
        
       		return nil, err

     

       124
        
       	}

     

       125
        
       

     

       126
       -
       	var events []TimelineEvent

     

       127
        
       	for _, r := range repos {

     

       128
        
       		var source *models.Repo

     

       129
        
       		if r.Source != "" {

     
···

       134
        
       

     

       135
        
       		isStarred, starCount := getRepoStarInfo(&r, starStatuses)

     

       136
        
       

     

       137
       -
       		events = append(events, TimelineEvent{

     

       138
        
       			Repo:      &r,

     

       139
        
       			EventAt:   r.Created,

     

       140
        
       			Source:    source,

     
···

       146
        
       	return events, nil

     

       147
        
       }

     

       148
        
       

     

       149
       -
       func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       150
        
       	stars, err := GetStars(e, limit)

     

       151
        
       	if err != nil {

     

       152
        
       		return nil, err

     
···

       172
        
       		return nil, err

     

       173
        
       	}

     

       174
        
       

     

       175
       -
       	var events []TimelineEvent

     

       176
        
       	for _, s := range stars {

     

       177
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       178
        
       

     

       179
       -
       		events = append(events, TimelineEvent{

     

       180
        
       			Star:      &s,

     

       181
        
       			EventAt:   s.Created,

     

       182
        
       			IsStarred: isStarred,

     
···

       187
        
       	return events, nil

     

       188
        
       }

     

       189
        
       

     

       190
       -
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]TimelineEvent, error) {

     

       191
        
       	follows, err := GetFollows(e, limit)

     

       192
        
       	if err != nil {

     

       193
        
       		return nil, err

     
···

       220
        
       		}

     

       221
        
       	}

     

       222
        
       

     

       223
       -
       	var events []TimelineEvent

     

       224
        
       	for _, f := range follows {

     

       225
        
       		profile, _ := profiles[f.SubjectDid]

     

       226
        
       		followStatMap, _ := followStatMap[f.SubjectDid]

     
···

       230
        
       			followStatus = followStatuses[f.SubjectDid]

     

       231
        
       		}

     

       232
        
       

     

       233
       -
       		events = append(events, TimelineEvent{

     

       234
        
       			Follow:       &f,

     

       235
        
       			Profile:      profile,

     

       236
        
       			FollowStats:  &followStatMap,

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"sort"

     

       0
        
       
     

       5
        
       

     

       6
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       7
        
       	"tangled.org/core/appview/models"

     

       8
        
       )

     

       9
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       10
        
       // TODO: this gathers heterogenous events from different sources and aggregates

     

       11
        
       // them in code; if we did this entirely in sql, we could order and limit and paginate easily

     

       12
       +
       func MakeTimeline(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       13
       +
       	var events []models.TimelineEvent

     

       14
        
       

     

       15
        
       	repos, err := getTimelineRepos(e, limit, loggedInUserDid)

     

       16
        
       	if err != nil {

     
···

       70
        
       	return isStarred, starCount

     

       71
        
       }

     

       72
        
       

     

       73
       +
       func getTimelineRepos(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       74
        
       	repos, err := GetRepos(e, limit)

     

       75
        
       	if err != nil {

     

       76
        
       		return nil, err

     
···

       102
        
       		return nil, err

     

       103
        
       	}

     

       104
        
       

     

       105
       +
       	var events []models.TimelineEvent

     

       106
        
       	for _, r := range repos {

     

       107
        
       		var source *models.Repo

     

       108
        
       		if r.Source != "" {

     
···

       113
        
       

     

       114
        
       		isStarred, starCount := getRepoStarInfo(&r, starStatuses)

     

       115
        
       

     

       116
       +
       		events = append(events, models.TimelineEvent{

     

       117
        
       			Repo:      &r,

     

       118
        
       			EventAt:   r.Created,

     

       119
        
       			Source:    source,

     
···

       125
        
       	return events, nil

     

       126
        
       }

     

       127
        
       

     

       128
       +
       func getTimelineStars(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       129
        
       	stars, err := GetStars(e, limit)

     

       130
        
       	if err != nil {

     

       131
        
       		return nil, err

     
···

       151
        
       		return nil, err

     

       152
        
       	}

     

       153
        
       

     

       154
       +
       	var events []models.TimelineEvent

     

       155
        
       	for _, s := range stars {

     

       156
        
       		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)

     

       157
        
       

     

       158
       +
       		events = append(events, models.TimelineEvent{

     

       159
        
       			Star:      &s,

     

       160
        
       			EventAt:   s.Created,

     

       161
        
       			IsStarred: isStarred,

     
···

       166
        
       	return events, nil

     

       167
        
       }

     

       168
        
       

     

       169
       +
       func getTimelineFollows(e Execer, limit int, loggedInUserDid string) ([]models.TimelineEvent, error) {

     

       170
        
       	follows, err := GetFollows(e, limit)

     

       171
        
       	if err != nil {

     

       172
        
       		return nil, err

     
···

       199
        
       		}

     

       200
        
       	}

     

       201
        
       

     

       202
       +
       	var events []models.TimelineEvent

     

       203
        
       	for _, f := range follows {

     

       204
        
       		profile, _ := profiles[f.SubjectDid]

     

       205
        
       		followStatMap, _ := followStatMap[f.SubjectDid]

     
···

       209
        
       			followStatus = followStatuses[f.SubjectDid]

     

       210
        
       		}

     

       211
        
       

     

       212
       +
       		events = append(events, models.TimelineEvent{

     

       213
        
       			Follow:       &f,

     

       214
        
       			Profile:      profile,

     

       215
        
       			FollowStats:  &followStatMap,

+23

appview/models/timeline.go

···

       1
       +
       package models

     

       2
       +
       

     

       3
       +
       import "time"

     

       4
       +
       

     

       5
       +
       type TimelineEvent struct {

     

       6
       +
       	*Repo

     

       7
       +
       	*Follow

     

       8
       +
       	*Star

     

       9
       +
       

     

       10
       +
       	EventAt time.Time

     

       11
       +
       

     

       12
       +
       	// optional: populate only if Repo is a fork

     

       13
       +
       	Source *Repo

     

       14
       +
       

     

       15
       +
       	// optional: populate only if event is Follow

     

       16
       +
       	*Profile

     

       17
       +
       	*FollowStats

     

       18
       +
       	*FollowStatus

     

       19
       +
       

     

       20
       +
       	// optional: populate only if event is Repo

     

       21
       +
       	IsStarred bool

     

       22
       +
       	StarCount int64

     

       23
       +
       }

+1 -1

appview/db/label.go

···

       349
        
       		defs[l.AtUri().String()] = &l

     

       350
        
       	}

     

       351
        
       

     

       352
       -
       	return &models.LabelApplicationCtx{defs}, nil

     

       353
        
       }

···

       349
        
       		defs[l.AtUri().String()] = &l

     

       350
        
       	}

     

       351
        
       

     

       352
       +
       	return &models.LabelApplicationCtx{Defs: defs}, nil

     

       353
        
       }

+15 -15

appview/pages/funcmap.go

···

       141
        
       		"relTimeFmt": humanize.Time,

     

       142
        
       		"shortRelTimeFmt": func(t time.Time) string {

     

       143
        
       			return humanize.CustomRelTime(t, time.Now(), "", "", []humanize.RelTimeMagnitude{

     

       144
       -
       				{time.Second, "now", time.Second},

     

       145
       -
       				{2 * time.Second, "1s %s", 1},

     

       146
       -
       				{time.Minute, "%ds %s", time.Second},

     

       147
       -
       				{2 * time.Minute, "1min %s", 1},

     

       148
       -
       				{time.Hour, "%dmin %s", time.Minute},

     

       149
       -
       				{2 * time.Hour, "1hr %s", 1},

     

       150
       -
       				{humanize.Day, "%dhrs %s", time.Hour},

     

       151
       -
       				{2 * humanize.Day, "1d %s", 1},

     

       152
       -
       				{20 * humanize.Day, "%dd %s", humanize.Day},

     

       153
       -
       				{8 * humanize.Week, "%dw %s", humanize.Week},

     

       154
       -
       				{humanize.Year, "%dmo %s", humanize.Month},

     

       155
       -
       				{18 * humanize.Month, "1y %s", 1},

     

       156
       -
       				{2 * humanize.Year, "2y %s", 1},

     

       157
       -
       				{humanize.LongTime, "%dy %s", humanize.Year},

     

       158
       -
       				{math.MaxInt64, "a long while %s", 1},

     

       159
        
       			})

     

       160
        
       		},

     

       161
        
       		"longTimeFmt": func(t time.Time) string {

···

       141
        
       		"relTimeFmt": humanize.Time,

     

       142
        
       		"shortRelTimeFmt": func(t time.Time) string {

     

       143
        
       			return humanize.CustomRelTime(t, time.Now(), "", "", []humanize.RelTimeMagnitude{

     

       144
       +
       				{D: time.Second, Format: "now", DivBy: time.Second},

     

       145
       +
       				{D: 2 * time.Second, Format: "1s %s", DivBy: 1},

     

       146
       +
       				{D: time.Minute, Format: "%ds %s", DivBy: time.Second},

     

       147
       +
       				{D: 2 * time.Minute, Format: "1min %s", DivBy: 1},

     

       148
       +
       				{D: time.Hour, Format: "%dmin %s", DivBy: time.Minute},

     

       149
       +
       				{D: 2 * time.Hour, Format: "1hr %s", DivBy: 1},

     

       150
       +
       				{D: humanize.Day, Format: "%dhrs %s", DivBy: time.Hour},

     

       151
       +
       				{D: 2 * humanize.Day, Format: "1d %s", DivBy: 1},

     

       152
       +
       				{D: 20 * humanize.Day, Format: "%dd %s", DivBy: humanize.Day},

     

       153
       +
       				{D: 8 * humanize.Week, Format: "%dw %s", DivBy: humanize.Week},

     

       154
       +
       				{D: humanize.Year, Format: "%dmo %s", DivBy: humanize.Month},

     

       155
       +
       				{D: 18 * humanize.Month, Format: "1y %s", DivBy: 1},

     

       156
       +
       				{D: 2 * humanize.Year, Format: "2y %s", DivBy: 1},

     

       157
       +
       				{D: humanize.LongTime, Format: "%dy %s", DivBy: humanize.Year},

     

       158
       +
       				{D: math.MaxInt64, Format: "a long while %s", DivBy: 1},

     

       159
        
       			})

     

       160
        
       		},

     

       161
        
       		"longTimeFmt": func(t time.Time) string {

+30

appview/pages/funcmap_test.go

···

       1
       +
       package pages

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"html/template"

     

       5
       +
       	"tangled.org/core/appview/config"

     

       6
       +
       	"tangled.org/core/idresolver"

     

       7
       +
       	"testing"

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       func TestPages_funcMap(t *testing.T) {

     

       11
       +
       	tests := []struct {

     

       12
       +
       		name string // description of this test case

     

       13
       +
       		// Named input parameters for receiver constructor.

     

       14
       +
       		config *config.Config

     

       15
       +
       		res    *idresolver.Resolver

     

       16
       +
       		want   template.FuncMap

     

       17
       +
       	}{

     

       18
       +
       		// TODO: Add test cases.

     

       19
       +
       	}

     

       20
       +
       	for _, tt := range tests {

     

       21
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       22
       +
       			p := NewPages(tt.config, tt.res)

     

       23
       +
       			got := p.funcMap()

     

       24
       +
       			// TODO: update the condition below to compare got with tt.want.

     

       25
       +
       			if true {

     

       26
       +
       				t.Errorf("funcMap() = %v, want %v", got, tt.want)

     

       27
       +
       			}

     

       28
       +
       		})

     

       29
       +
       	}

     

       30
       +
       }

+40 -14

appview/repo/artifact.go

···

       4
        
       	"context"

     

       5
        
       	"encoding/json"

     

       6
        
       	"fmt"

     

       0
        
       
     

       7
        
       	"log"

     

       8
        
       	"net/http"

     

       9
        
       	"net/url"

     
···

       134
        
       	})

     

       135
        
       }

     

       136
        
       

     

       137
       -
       // TODO: proper statuses here on early exit

     

       138
        
       func (rp *Repo) DownloadArtifact(w http.ResponseWriter, r *http.Request) {

     

       139
       -
       	tagParam := chi.URLParam(r, "tag")

     

       140
       -
       	filename := chi.URLParam(r, "file")

     

       141
        
       	f, err := rp.repoResolver.Resolve(r)

     

       142
        
       	if err != nil {

     

       143
        
       		log.Println("failed to get repo and knot", err)

     

       0
        
       
     

       144
        
       		return

     

       145
        
       	}

     

       146
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       147
        
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       148
        
       	if err != nil {

     

       149
        
       		log.Println("failed to resolve tag", err)

     
···

       151
        
       		return

     

       152
        
       	}

     

       153
        
       

     

       154
       -
       	client, err := rp.oauth.AuthorizedClient(r)

     

       155
       -
       	if err != nil {

     

       156
       -
       		log.Println("failed to get authorized client", err)

     

       157
       -
       		return

     

       158
       -
       	}

     

       159
       -
       

     

       160
        
       	artifacts, err := db.GetArtifact(

     

       161
        
       		rp.db,

     

       162
        
       		db.FilterEq("repo_at", f.RepoAt()),

     
···

       165
        
       	)

     

       166
        
       	if err != nil {

     

       167
        
       		log.Println("failed to get artifacts", err)

     

       0
        
       
     

       168
        
       		return

     

       169
        
       	}

     

       0
        
       
     

       170
        
       	if len(artifacts) != 1 {

     

       171
       -
       		log.Printf("too many or too little artifacts found")

     

       0
        
       
     

       172
        
       		return

     

       173
        
       	}

     

       174
        
       

     

       175
        
       	artifact := artifacts[0]

     

       176
        
       

     

       177
       -
       	getBlobResp, err := client.SyncGetBlob(r.Context(), artifact.BlobCid.String(), artifact.Did)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178
        
       	if err != nil {

     

       179
       -
       		log.Println("failed to get blob from pds", err)

     

       0
        
       
     

       180
        
       		return

     

       181
        
       	}

     

       0
        
       
     

       182
        
       

     

       183
       -
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", filename))

     

       184
       -
       	w.Write(getBlobResp)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       185
        
       }

     

       186
        
       

     

       187
        
       // TODO: proper statuses here on early exit

···

       4
        
       	"context"

     

       5
        
       	"encoding/json"

     

       6
        
       	"fmt"

     

       7
       +
       	"io"

     

       8
        
       	"log"

     

       9
        
       	"net/http"

     

       10
        
       	"net/url"

     
···

       135
        
       	})

     

       136
        
       }

     

       137
        
       

     

       0
        
       
     

       138
        
       func (rp *Repo) DownloadArtifact(w http.ResponseWriter, r *http.Request) {

     

       0
        
       
     

       0
        
       
     

       139
        
       	f, err := rp.repoResolver.Resolve(r)

     

       140
        
       	if err != nil {

     

       141
        
       		log.Println("failed to get repo and knot", err)

     

       142
       +
       		http.Error(w, "failed to resolve repo", http.StatusInternalServerError)

     

       143
        
       		return

     

       144
        
       	}

     

       145
        
       

     

       146
       +
       	tagParam := chi.URLParam(r, "tag")

     

       147
       +
       	filename := chi.URLParam(r, "file")

     

       148
       +
       

     

       149
        
       	tag, err := rp.resolveTag(r.Context(), f, tagParam)

     

       150
        
       	if err != nil {

     

       151
        
       		log.Println("failed to resolve tag", err)

     
···

       153
        
       		return

     

       154
        
       	}

     

       155
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       156
        
       	artifacts, err := db.GetArtifact(

     

       157
        
       		rp.db,

     

       158
        
       		db.FilterEq("repo_at", f.RepoAt()),

     
···

       161
        
       	)

     

       162
        
       	if err != nil {

     

       163
        
       		log.Println("failed to get artifacts", err)

     

       164
       +
       		http.Error(w, "failed to get artifact", http.StatusInternalServerError)

     

       165
        
       		return

     

       166
        
       	}

     

       167
       +
       

     

       168
        
       	if len(artifacts) != 1 {

     

       169
       +
       		log.Printf("too many or too few artifacts found")

     

       170
       +
       		http.Error(w, "artifact not found", http.StatusNotFound)

     

       171
        
       		return

     

       172
        
       	}

     

       173
        
       

     

       174
        
       	artifact := artifacts[0]

     

       175
        
       

     

       176
       +
       	ownerPds := f.OwnerId.PDSEndpoint()

     

       177
       +
       	url, _ := url.Parse(fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob", ownerPds))

     

       178
       +
       	q := url.Query()

     

       179
       +
       	q.Set("cid", artifact.BlobCid.String())

     

       180
       +
       	q.Set("did", artifact.Did)

     

       181
       +
       	url.RawQuery = q.Encode()

     

       182
       +
       

     

       183
       +
       	req, err := http.NewRequest(http.MethodGet, url.String(), nil)

     

       184
        
       	if err != nil {

     

       185
       +
       		log.Println("failed to create request", err)

     

       186
       +
       		http.Error(w, "failed to create request", http.StatusInternalServerError)

     

       187
        
       		return

     

       188
        
       	}

     

       189
       +
       	req.Header.Set("Content-Type", "application/json")

     

       190
        
       

     

       191
       +
       	resp, err := http.DefaultClient.Do(req)

     

       192
       +
       	if err != nil {

     

       193
       +
       		log.Println("failed to make request", err)

     

       194
       +
       		http.Error(w, "failed to make request to PDS", http.StatusInternalServerError)

     

       195
       +
       		return

     

       196
       +
       	}

     

       197
       +
       	defer resp.Body.Close()

     

       198
       +
       

     

       199
       +
       	// copy status code and relevant headers from upstream response

     

       200
       +
       	w.WriteHeader(resp.StatusCode)

     

       201
       +
       	for key, values := range resp.Header {

     

       202
       +
       		for _, v := range values {

     

       203
       +
       			w.Header().Add(key, v)

     

       204
       +
       		}

     

       205
       +
       	}

     

       206
       +
       

     

       207
       +
       	// stream the body directly to the client

     

       208
       +
       	if _, err := io.Copy(w, resp.Body); err != nil {

     

       209
       +
       		log.Println("error streaming response to client:", err)

     

       210
       +
       	}

     

       211
        
       }

     

       212
        
       

     

       213
        
       // TODO: proper statuses here on early exit

+36 -6

appview/pages/templates/repo/settings/general.html

···

       46
        
       

     

       47
        
       {{ define "defaultLabelSettings" }}

     

       48
        
         <div class="flex flex-col gap-2">

     

       49
       -
           <h2 class="text-sm pb-2 uppercase font-bold">Default Labels</h2>

     

       50
       -
           <p class="text-gray-500 dark:text-gray-400">

     

       51
       -
             Manage your issues and pulls by creating labels to categorize them. Only

     

       52
       -
             repository owners may configure labels. You may choose to subscribe to

     

       53
       -
             default labels, or create entirely custom labels.

     

       54
       -
           </p>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       55
        
           <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 w-full">

     

       56
        
             {{ range .DefaultLabels }}

     

       57
        
               <div id="label-{{.Id}}" class="flex items-center justify-between p-2 pl-4">

···

       46
        
       

     

       47
        
       {{ define "defaultLabelSettings" }}

     

       48
        
         <div class="flex flex-col gap-2">

     

       49
       +
           <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       50
       +
             <div class="col-span-1 md:col-span-2">

     

       51
       +
               <h2 class="text-sm pb-2 uppercase font-bold">Default Labels</h2>

     

       52
       +
               <p class="text-gray-500 dark:text-gray-400">

     

       53
       +
                 Manage your issues and pulls by creating labels to categorize them. Only

     

       54
       +
                 repository owners may configure labels. You may choose to subscribe to

     

       55
       +
                 default labels, or create entirely custom labels.

     

       56
       +
               <p>

     

       57
       +
             </div>

     

       58
       +
             <form class="col-span-1 md:col-span-1 md:justify-self-end">

     

       59
       +
               {{ $title := "Unubscribe from all labels" }}

     

       60
       +
               {{ $icon := "x" }}

     

       61
       +
               {{ $text := "unsubscribe all" }}

     

       62
       +
               {{ $action := "unsubscribe" }}

     

       63
       +
               {{ if $.ShouldSubscribeAll }}

     

       64
       +
                 {{ $title = "Subscribe to all labels" }}

     

       65
       +
                 {{ $icon = "check-check" }}

     

       66
       +
                 {{ $text = "subscribe all" }}

     

       67
       +
                 {{ $action = "subscribe" }}

     

       68
       +
               {{ end }}

     

       69
       +
               {{ range .DefaultLabels }}

     

       70
       +
                 <input type="hidden" name="label" value="{{ .AtUri.String }}">

     

       71
       +
               {{ end }}

     

       72
       +
               <button

     

       73
       +
                 type="submit"

     

       74
       +
                 title="{{$title}}" 

     

       75
       +
                 class="btn flex items-center gap-2 group"

     

       76
       +
                 hx-swap="none"

     

       77
       +
                 hx-post="/{{ $.RepoInfo.FullName }}/settings/label/{{$action}}"

     

       78
       +
                 {{ if not .RepoInfo.Roles.IsOwner }}disabled{{ end }}>

     

       79
       +
                 {{ i $icon "size-4" }}

     

       80
       +
                 {{ $text }}

     

       81
       +
                 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       82
       +
               </button>

     

       83
       +
             </form>

     

       84
       +
           </div>

     

       85
        
           <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 w-full">

     

       86
        
             {{ range .DefaultLabels }}

     

       87
        
               <div id="label-{{.Id}}" class="flex items-center justify-between p-2 pl-4">

+10 -33

appview/pages/templates/timeline/fragments/timeline.html

···

       82
        
         {{ $event := index . 1 }}

     

       83
        
         {{ $follow := $event.Follow }}

     

       84
        
         {{ $profile := $event.Profile }}

     

       85
       -
         {{ $stat := $event.FollowStats }}

     

       0
        
       
     

       86
        
       

     

       87
        
         {{ $userHandle :=  resolve $follow.UserDid }}

     

       88
        
         {{ $subjectHandle :=  resolve $follow.SubjectDid }}

     
···

       92
        
             {{ template "user/fragments/picHandleLink" $subjectHandle }}

     

       93
        
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $follow.FollowedAt }}</span>

     

       94
        
         </div>

     

       95
       -
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex flex-col md:flex-row md:items-center gap-4">

     

       96
       -
           <div class="flex items-center gap-4 flex-1">

     

       97
       -
             <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       98
       -
               <img alt="" class="object-cover rounded-full p-2" src="{{ fullAvatar $subjectHandle }}" />

     

       99
       -
             </div>

     

       100
       -
       

     

       101
       -
             <div class="flex-1 min-h-0 justify-around flex flex-col">

     

       102
       -
               <a href="/{{ $subjectHandle }}">

     

       103
       -
                 <span class="font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap max-w-full">{{ $subjectHandle | truncateAt30 }}</span>

     

       104
       -
               </a>

     

       105
       -
               {{ with $profile }}

     

       106
       -
                 {{ with .Description }}

     

       107
       -
                   <p class="text-sm pb-2 md:pb-2">{{.}}</p>

     

       108
       -
                 {{ end }}

     

       109
       -
               {{ end }}

     

       110
       -
               {{ with $stat }}

     

       111
       -
                 <div class="text-sm flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full">

     

       112
       -
                   <span class="flex-shrink-0">{{ i "users" "size-4" }}</span>

     

       113
       -
                   <span id="followers"><a href="/{{ $subjectHandle }}?tab=followers">{{ .Followers }} followers</a></span>

     

       114
       -
                   <span class="select-none after:content-['·']"></span>

     

       115
       -
                   <span id="following"><a href="/{{ $subjectHandle }}?tab=following">{{ .Following }} following</a></span>

     

       116
       -
                 </div>

     

       117
       -
               {{ end }}

     

       118
       -
             </div>

     

       119
       -
           </div>

     

       120
       -
           

     

       121
       -
           {{ if and $root.LoggedInUser (ne $event.FollowStatus.String "IsSelf") }}

     

       122
       -
             <div class="flex-shrink-0 w-fit ml-auto">

     

       123
       -
               {{ template "user/fragments/follow" (dict "UserDid" $follow.SubjectDid "FollowStatus" $event.FollowStatus) }}

     

       124
       -
             </div>

     

       125
       -
           {{ end }}

     

       126
       -
         </div>

     

       127
        
       {{ end }}

···

       82
        
         {{ $event := index . 1 }}

     

       83
        
         {{ $follow := $event.Follow }}

     

       84
        
         {{ $profile := $event.Profile }}

     

       85
       +
         {{ $followStats := $event.FollowStats }}

     

       86
       +
         {{ $followStatus := $event.FollowStatus }}

     

       87
        
       

     

       88
        
         {{ $userHandle :=  resolve $follow.UserDid }}

     

       89
        
         {{ $subjectHandle :=  resolve $follow.SubjectDid }}

     
···

       93
        
             {{ template "user/fragments/picHandleLink" $subjectHandle }}

     

       94
        
             <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $follow.FollowedAt }}</span>

     

       95
        
         </div>

     

       96
       +
         {{ template "user/fragments/followCard" 

     

       97
       +
             (dict

     

       98
       +
                 "LoggedInUser" $root.LoggedInUser

     

       99
       +
                 "UserDid" $follow.SubjectDid

     

       100
       +
                 "Profile" $profile

     

       101
       +
                 "FollowStatus" $followStatus

     

       102
       +
                 "FollowersCount" $followStats.Followers

     

       103
       +
                 "FollowingCount" $followStats.Following) }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       104
        
       {{ end }}

+8 -1

appview/pages/templates/user/followers.html

···

       10
        
         <p class="text-sm font-bold p-2 dark:text-white">ALL FOLLOWERS</p>

     

       11
        
         <div id="followers" class="grid grid-cols-1 gap-4 mb-6">

     

       12
        
           {{ range .Followers }}

     

       13
       -
              {{ template "user/fragments/followCard" . }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
           {{ else }}

     

       15
        
               <p class="px-6 dark:text-white">This user does not have any followers yet.</p>

     

       16
        
           {{ end }}

···

       10
        
         <p class="text-sm font-bold p-2 dark:text-white">ALL FOLLOWERS</p>

     

       11
        
         <div id="followers" class="grid grid-cols-1 gap-4 mb-6">

     

       12
        
           {{ range .Followers }}

     

       13
       +
              {{ template "user/fragments/followCard"

     

       14
       +
                 (dict

     

       15
       +
                     "LoggedInUser" $.LoggedInUser

     

       16
       +
                     "UserDid" .UserDid

     

       17
       +
                     "Profile" .Profile

     

       18
       +
                     "FollowStatus" .FollowStatus

     

       19
       +
                     "FollowersCount" .FollowersCount

     

       20
       +
                     "FollowingCount" .FollowingCount) }}

     

       21
        
           {{ else }}

     

       22
        
               <p class="px-6 dark:text-white">This user does not have any followers yet.</p>

     

       23
        
           {{ end }}

+8 -1

appview/pages/templates/user/following.html

···

       10
        
         <p class="text-sm font-bold p-2 dark:text-white">ALL FOLLOWING</p>

     

       11
        
         <div id="following" class="grid grid-cols-1 gap-4 mb-6">

     

       12
        
           {{ range .Following }}

     

       13
       -
              {{ template "user/fragments/followCard" . }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       14
        
           {{ else }}

     

       15
        
               <p class="px-6 dark:text-white">This user does not follow anyone yet.</p>

     

       16
        
           {{ end }}

···

       10
        
         <p class="text-sm font-bold p-2 dark:text-white">ALL FOLLOWING</p>

     

       11
        
         <div id="following" class="grid grid-cols-1 gap-4 mb-6">

     

       12
        
           {{ range .Following }}

     

       13
       +
              {{ template "user/fragments/followCard"

     

       14
       +
                 (dict

     

       15
       +
                     "LoggedInUser" $.LoggedInUser

     

       16
       +
                     "UserDid" .UserDid

     

       17
       +
                     "Profile" .Profile

     

       18
       +
                     "FollowStatus" .FollowStatus

     

       19
       +
                     "FollowersCount" .FollowersCount

     

       20
       +
                     "FollowingCount" .FollowingCount) }}

     

       21
        
           {{ else }}

     

       22
        
               <p class="px-6 dark:text-white">This user does not follow anyone yet.</p>

     

       23
        
           {{ end }}

+6 -2

appview/pages/templates/user/fragments/follow.html

···

       1
        
       {{ define "user/fragments/follow" }}

     

       2
        
         <button id="{{ normalizeForHtmlId .UserDid }}"

     

       3
       -
           class="btn mt-2 flex gap-2 items-center group"

     

       4
        
       

     

       5
        
           {{ if eq .FollowStatus.String "IsNotFollowing" }}

     

       6
        
           hx-post="/follow?subject={{.UserDid}}"

     
···

       12
        
           hx-target="#{{ normalizeForHtmlId .UserDid }}"

     

       13
        
           hx-swap="outerHTML"

     

       14
        
           >

     

       15
       -
           {{ if eq .FollowStatus.String "IsNotFollowing" }}{{ i "user-round-plus" "w-4 h-4" }} follow{{ else }}{{ i "user-round-minus" "w-4 h-4" }} unfollow{{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       17
        
         </button>

     

       18
        
       {{ end }}

···

       1
        
       {{ define "user/fragments/follow" }}

     

       2
        
         <button id="{{ normalizeForHtmlId .UserDid }}"

     

       3
       +
           class="btn w-full flex gap-2 items-center group"

     

       4
        
       

     

       5
        
           {{ if eq .FollowStatus.String "IsNotFollowing" }}

     

       6
        
           hx-post="/follow?subject={{.UserDid}}"

     
···

       12
        
           hx-target="#{{ normalizeForHtmlId .UserDid }}"

     

       13
        
           hx-swap="outerHTML"

     

       14
        
           >

     

       15
       +
           {{ if eq .FollowStatus.String "IsNotFollowing" }}

     

       16
       +
             {{ i "user-round-plus" "w-4 h-4" }} follow

     

       17
       +
           {{ else }}

     

       18
       +
             {{ i "user-round-minus" "w-4 h-4" }} unfollow

     

       19
       +
           {{ end }}

     

       20
        
           {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       21
        
         </button>

     

       22
        
       {{ end }}

+58 -3

appview/posthog/notifier.go appview/notify/posthog/notifier.go

···

       1
       -
       package posthog_service

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"context"

     
···

       98
        
       	}

     

       99
        
       }

     

       100
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       101
        
       func (n *posthogNotifier) NewFollow(ctx context.Context, follow *models.Follow) {

     

       102
        
       	err := n.client.Enqueue(posthog.Capture{

     

       103
        
       		DistinctId: follow.UserDid,

     
···

       152
        
       	}

     

       153
        
       }

     

       154
        
       

     

       155
       -
       func (n *posthogNotifier) CreateString(ctx context.Context, string models.String) {

     

       156
        
       	err := n.client.Enqueue(posthog.Capture{

     

       157
        
       		DistinctId: string.Did.String(),

     

       158
       -
       		Event:      "create_string",

     

       159
        
       		Properties: posthog.Properties{"rkey": string.Rkey},

     

       160
        
       	})

     

       161
        
       	if err != nil {

     

       162
        
       		log.Println("failed to enqueue posthog event:", err)

     

       163
        
       	}

     

       164
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
       +
       package posthog

     

       2
        
       

     

       3
        
       import (

     

       4
        
       	"context"

     
···

       98
        
       	}

     

       99
        
       }

     

       100
        
       

     

       101
       +
       func (n *posthogNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       102
       +
       	err := n.client.Enqueue(posthog.Capture{

     

       103
       +
       		DistinctId: pull.OwnerDid,

     

       104
       +
       		Event:      "pull_closed",

     

       105
       +
       		Properties: posthog.Properties{

     

       106
       +
       			"repo_at": pull.RepoAt,

     

       107
       +
       			"pull_id": pull.PullId,

     

       108
       +
       		},

     

       109
       +
       	})

     

       110
       +
       	if err != nil {

     

       111
       +
       		log.Println("failed to enqueue posthog event:", err)

     

       112
       +
       	}

     

       113
       +
       }

     

       114
       +
       

     

       115
        
       func (n *posthogNotifier) NewFollow(ctx context.Context, follow *models.Follow) {

     

       116
        
       	err := n.client.Enqueue(posthog.Capture{

     

       117
        
       		DistinctId: follow.UserDid,

     
···

       166
        
       	}

     

       167
        
       }

     

       168
        
       

     

       169
       +
       func (n *posthogNotifier) NewString(ctx context.Context, string *models.String) {

     

       170
        
       	err := n.client.Enqueue(posthog.Capture{

     

       171
        
       		DistinctId: string.Did.String(),

     

       172
       +
       		Event:      "new_string",

     

       173
        
       		Properties: posthog.Properties{"rkey": string.Rkey},

     

       174
        
       	})

     

       175
        
       	if err != nil {

     

       176
        
       		log.Println("failed to enqueue posthog event:", err)

     

       177
        
       	}

     

       178
        
       }

     

       179
       +
       

     

       180
       +
       func (n *posthogNotifier) NewIssueComment(ctx context.Context, comment *models.IssueComment) {

     

       181
       +
       	err := n.client.Enqueue(posthog.Capture{

     

       182
       +
       		DistinctId: comment.Did,

     

       183
       +
       		Event:      "new_issue_comment",

     

       184
       +
       		Properties: posthog.Properties{

     

       185
       +
       			"issue_at": comment.IssueAt,

     

       186
       +
       		},

     

       187
       +
       	})

     

       188
       +
       	if err != nil {

     

       189
       +
       		log.Println("failed to enqueue posthog event:", err)

     

       190
       +
       	}

     

       191
       +
       }

     

       192
       +
       

     

       193
       +
       func (n *posthogNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       194
       +
       	err := n.client.Enqueue(posthog.Capture{

     

       195
       +
       		DistinctId: issue.Did,

     

       196
       +
       		Event:      "issue_closed",

     

       197
       +
       		Properties: posthog.Properties{

     

       198
       +
       			"repo_at":  issue.RepoAt.String(),

     

       199
       +
       			"issue_id": issue.IssueId,

     

       200
       +
       		},

     

       201
       +
       	})

     

       202
       +
       	if err != nil {

     

       203
       +
       		log.Println("failed to enqueue posthog event:", err)

     

       204
       +
       	}

     

       205
       +
       }

     

       206
       +
       

     

       207
       +
       func (n *posthogNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       208
       +
       	err := n.client.Enqueue(posthog.Capture{

     

       209
       +
       		DistinctId: pull.OwnerDid,

     

       210
       +
       		Event:      "pull_merged",

     

       211
       +
       		Properties: posthog.Properties{

     

       212
       +
       			"repo_at": pull.RepoAt,

     

       213
       +
       			"pull_id": pull.PullId,

     

       214
       +
       		},

     

       215
       +
       	})

     

       216
       +
       	if err != nil {

     

       217
       +
       		log.Println("failed to enqueue posthog event:", err)

     

       218
       +
       	}

     

       219
       +
       }

+36 -6

appview/db/repos.go

···

       10
        
       	"time"

     

       11
        
       

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       0
        
       
     

       0
        
       
     

       13
        
       	"tangled.org/core/appview/models"

     

       14
        
       )

     

       15
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {

     

       17
        
       	repoMap := make(map[syntax.ATURI]*models.Repo)

     

       18
        
       

     
···

       35
        
       

     

       36
        
       	repoQuery := fmt.Sprintf(

     

       37
        
       		`select

     

       0
        
       
     

       38
        
       			did,

     

       39
        
       			name,

     

       40
        
       			knot,

     
···

       63
        
       		var description, source, spindle sql.NullString

     

       64
        
       

     

       65
        
       		err := rows.Scan(

     

       0
        
       
     

       66
        
       			&repo.Did,

     

       67
        
       			&repo.Name,

     

       68
        
       			&repo.Knot,

     
···

       327
        
       	var repo models.Repo

     

       328
        
       	var nullableDescription sql.NullString

     

       329
        
       

     

       330
       -
       	row := e.QueryRow(`select did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri)

     

       331
        
       

     

       332
        
       	var createdAt string

     

       333
       -
       	if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription); err != nil {

     

       334
        
       		return nil, err

     

       335
        
       	}

     

       336
        
       	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     
···

       386
        
       	var repos []models.Repo

     

       387
        
       

     

       388
        
       	rows, err := e.Query(

     

       389
       -
       		`select distinct r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source

     

       390
        
       		from repos r

     

       391
        
       		left join collaborators c on r.at_uri = c.repo_at

     

       392
        
       		where (r.did = ? or c.subject_did = ?)

     
···

       406
        
       		var nullableDescription sql.NullString

     

       407
        
       		var nullableSource sql.NullString

     

       408
        
       

     

       409
       -
       		err := rows.Scan(&repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       410
        
       		if err != nil {

     

       411
        
       			return nil, err

     

       412
        
       		}

     
···

       443
        
       	var nullableSource sql.NullString

     

       444
        
       

     

       445
        
       	row := e.QueryRow(

     

       446
       -
       		`select did, name, knot, rkey, description, created, source

     

       447
        
       		from repos

     

       448
        
       		where did = ? and name = ? and source is not null and source != ''`,

     

       449
        
       		did, name,

     

       450
        
       	)

     

       451
        
       

     

       452
       -
       	err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       453
        
       	if err != nil {

     

       454
        
       		return nil, err

     

       455
        
       	}

···

       10
        
       	"time"

     

       11
        
       

     

       12
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       13
       +
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       14
       +
       	"tangled.org/core/api/tangled"

     

       15
        
       	"tangled.org/core/appview/models"

     

       16
        
       )

     

       17
        
       

     

       18
       +
       type Repo struct {

     

       19
       +
       	Id          int64

     

       20
       +
       	Did         string

     

       21
       +
       	Name        string

     

       22
       +
       	Knot        string

     

       23
       +
       	Rkey        string

     

       24
       +
       	Created     time.Time

     

       25
       +
       	Description string

     

       26
       +
       	Spindle     string

     

       27
       +
       

     

       28
       +
       	// optionally, populate this when querying for reverse mappings

     

       29
       +
       	RepoStats *models.RepoStats

     

       30
       +
       

     

       31
       +
       	// optional

     

       32
       +
       	Source string

     

       33
       +
       }

     

       34
       +
       

     

       35
       +
       func (r Repo) RepoAt() syntax.ATURI {

     

       36
       +
       	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))

     

       37
       +
       }

     

       38
       +
       

     

       39
       +
       func (r Repo) DidSlashRepo() string {

     

       40
       +
       	p, _ := securejoin.SecureJoin(r.Did, r.Name)

     

       41
       +
       	return p

     

       42
       +
       }

     

       43
       +
       

     

       44
        
       func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {

     

       45
        
       	repoMap := make(map[syntax.ATURI]*models.Repo)

     

       46
        
       

     
···

       63
        
       

     

       64
        
       	repoQuery := fmt.Sprintf(

     

       65
        
       		`select

     

       66
       +
       			id,

     

       67
        
       			did,

     

       68
        
       			name,

     

       69
        
       			knot,

     
···

       92
        
       		var description, source, spindle sql.NullString

     

       93
        
       

     

       94
        
       		err := rows.Scan(

     

       95
       +
       			&repo.Id,

     

       96
        
       			&repo.Did,

     

       97
        
       			&repo.Name,

     

       98
        
       			&repo.Knot,

     
···

       357
        
       	var repo models.Repo

     

       358
        
       	var nullableDescription sql.NullString

     

       359
        
       

     

       360
       +
       	row := e.QueryRow(`select id, did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri)

     

       361
        
       

     

       362
        
       	var createdAt string

     

       363
       +
       	if err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &createdAt, &repo.Rkey, &nullableDescription); err != nil {

     

       364
        
       		return nil, err

     

       365
        
       	}

     

       366
        
       	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)

     
···

       416
        
       	var repos []models.Repo

     

       417
        
       

     

       418
        
       	rows, err := e.Query(

     

       419
       +
       		`select distinct r.id, r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source

     

       420
        
       		from repos r

     

       421
        
       		left join collaborators c on r.at_uri = c.repo_at

     

       422
        
       		where (r.did = ? or c.subject_did = ?)

     
···

       436
        
       		var nullableDescription sql.NullString

     

       437
        
       		var nullableSource sql.NullString

     

       438
        
       

     

       439
       +
       		err := rows.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       440
        
       		if err != nil {

     

       441
        
       			return nil, err

     

       442
        
       		}

     
···

       473
        
       	var nullableSource sql.NullString

     

       474
        
       

     

       475
        
       	row := e.QueryRow(

     

       476
       +
       		`select id, did, name, knot, rkey, description, created, source

     

       477
        
       		from repos

     

       478
        
       		where did = ? and name = ? and source is not null and source != ''`,

     

       479
        
       		did, name,

     

       480
        
       	)

     

       481
        
       

     

       482
       +
       	err := row.Scan(&repo.Id, &repo.Did, &repo.Name, &repo.Knot, &repo.Rkey, &nullableDescription, &createdAt, &nullableSource)

     

       483
        
       	if err != nil {

     

       484
        
       		return nil, err

     

       485
        
       	}

+12

appview/notify/merged_notifier.go

···

       72
        
       	}

     

       73
        
       }

     

       74
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       75
        
       func (m *mergedNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {

     

       76
        
       	for _, notifier := range m.notifiers {

     

       77
        
       		notifier.UpdateProfile(ctx, profile)

···

       72
        
       	}

     

       73
        
       }

     

       74
        
       

     

       75
       +
       func (m *mergedNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       76
       +
       	for _, notifier := range m.notifiers {

     

       77
       +
       		notifier.NewPullMerged(ctx, pull)

     

       78
       +
       	}

     

       79
       +
       }

     

       80
       +
       

     

       81
       +
       func (m *mergedNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       82
       +
       	for _, notifier := range m.notifiers {

     

       83
       +
       		notifier.NewPullClosed(ctx, pull)

     

       84
       +
       	}

     

       85
       +
       }

     

       86
       +
       

     

       87
        
       func (m *mergedNotifier) UpdateProfile(ctx context.Context, profile *models.Profile) {

     

       88
        
       	for _, notifier := range m.notifiers {

     

       89
        
       		notifier.UpdateProfile(ctx, profile)

+4 -11

appview/pages/templates/errors/500.html

···

       5
        
           <div class="bg-white dark:bg-gray-800 rounded-lg drop-shadow-sm p-8 max-w-lg mx-auto">

     

       6
        
               <div class="mb-6">

     

       7
        
                   <div class="w-16 h-16 mx-auto mb-4 rounded-full bg-red-100 dark:bg-red-900/30 flex items-center justify-center">

     

       8
       -
                       {{ i "alert-triangle" "w-8 h-8 text-red-500 dark:text-red-400" }}

     

       9
        
                   </div>

     

       10
        
               </div>

     

       11
        
       

     
···

       14
        
                       500 &mdash; internal server error

     

       15
        
                   </h1>

     

       16
        
                   <p class="text-gray-600 dark:text-gray-300">

     

       17
       -
                       Something went wrong on our end. We've been notified and are working to fix the issue.

     

       18
       -
                   </p>

     

       19
       -
                   <div class="bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800 rounded p-3 text-sm text-yellow-800 dark:text-yellow-200">

     

       20
       -
                       <div class="flex items-center gap-2">

     

       21
       -
                           {{ i "info" "w-4 h-4" }}

     

       22
       -
                           <span class="font-medium">we're on it!</span>

     

       23
       -
                       </div>

     

       24
       -
                       <p class="mt-1">Our team has been automatically notified about this error.</p>

     

       25
       -
                   </div>

     

       26
        
                   <div class="flex flex-col sm:flex-row gap-3 justify-center items-center mt-6">

     

       27
        
                       <button onclick="location.reload()" class="btn-create gap-2">

     

       28
        
                           {{ i "refresh-cw" "w-4 h-4" }}

     

       29
        
                           try again

     

       30
        
                       </button>

     

       31
        
                       <a href="/" class="btn no-underline hover:no-underline gap-2">

     

       32
       -
                           {{ i "home" "w-4 h-4" }}

     

       33
        
                           back to home

     

       34
        
                       </a>

     

       35
        
                   </div>

···

       5
        
           <div class="bg-white dark:bg-gray-800 rounded-lg drop-shadow-sm p-8 max-w-lg mx-auto">

     

       6
        
               <div class="mb-6">

     

       7
        
                   <div class="w-16 h-16 mx-auto mb-4 rounded-full bg-red-100 dark:bg-red-900/30 flex items-center justify-center">

     

       8
       +
                       {{ i "triangle-alert" "w-8 h-8 text-red-500 dark:text-red-400" }}

     

       9
        
                   </div>

     

       10
        
               </div>

     

       11
        
       

     
···

       14
        
                       500 &mdash; internal server error

     

       15
        
                   </h1>

     

       16
        
                   <p class="text-gray-600 dark:text-gray-300">

     

       17
       +
                       We encountered an error while processing your request. Please try again later.

     

       18
       +
                    </p>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
                   <div class="flex flex-col sm:flex-row gap-3 justify-center items-center mt-6">

     

       20
        
                       <button onclick="location.reload()" class="btn-create gap-2">

     

       21
        
                           {{ i "refresh-cw" "w-4 h-4" }}

     

       22
        
                           try again

     

       23
        
                       </button>

     

       24
        
                       <a href="/" class="btn no-underline hover:no-underline gap-2">

     

       25
       +
                           {{ i "arrow-left" "w-4 h-4" }}

     

       26
        
                           back to home

     

       27
        
                       </a>

     

       28
        
                   </div>

+173

appview/pages/templates/user/settings/notifications.html

···

       1
       +
       {{ define "title" }}{{ .Tab }} settings{{ end }}

     

       2
       +
       

     

       3
       +
       {{ define "content" }}

     

       4
       +
         <div class="p-6">

     

       5
       +
           <p class="text-xl font-bold dark:text-white">Settings</p>

     

       6
       +
         </div>

     

       7
       +
         <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       8
       +
           <section class="w-full grid grid-cols-1 md:grid-cols-4 gap-6">

     

       9
       +
             <div class="col-span-1">

     

       10
       +
               {{ template "user/settings/fragments/sidebar" . }}

     

       11
       +
             </div>

     

       12
       +
             <div class="col-span-1 md:col-span-3 flex flex-col gap-6">

     

       13
       +
               {{ template "notificationSettings" . }}

     

       14
       +
             </div>

     

       15
       +
           </section>

     

       16
       +
         </div>

     

       17
       +
       {{ end }}

     

       18
       +
       

     

       19
       +
       {{ define "notificationSettings" }}

     

       20
       +
         <div class="grid grid-cols-1 md:grid-cols-3 gap-4 items-center">

     

       21
       +
           <div class="col-span-1 md:col-span-2">

     

       22
       +
             <h2 class="text-sm pb-2 uppercase font-bold">Notification Preferences</h2>

     

       23
       +
             <p class="text-gray-500 dark:text-gray-400">

     

       24
       +
               Choose which notifications you want to receive when activity happens on your repositories and profile.

     

       25
       +
             </p>

     

       26
       +
           </div>

     

       27
       +
         </div>

     

       28
       +
       

     

       29
       +
         <form hx-put="/settings/notifications" hx-swap="none" class="flex flex-col gap-6">

     

       30
       +
       

     

       31
       +
           <div class="flex flex-col rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700 w-full">

     

       32
       +
             <div class="flex items-center justify-between p-2">

     

       33
       +
               <div class="flex items-center gap-2">

     

       34
       +
                 <div class="flex flex-col gap-1">

     

       35
       +
                   <span class="font-bold">Repository starred</span>

     

       36
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       37
       +
                     <span>When someone stars your repository.</span>

     

       38
       +
                   </div>

     

       39
       +
                 </div>

     

       40
       +
               </div>

     

       41
       +
               <label class="flex items-center gap-2">

     

       42
       +
                 <input type="checkbox" name="repo_starred" {{if .Preferences.RepoStarred}}checked{{end}}>

     

       43
       +
               </label>

     

       44
       +
             </div>

     

       45
       +
       

     

       46
       +
             <div class="flex items-center justify-between p-2">

     

       47
       +
               <div class="flex items-center gap-2">

     

       48
       +
                 <div class="flex flex-col gap-1">

     

       49
       +
                   <span class="font-bold">New issues</span>

     

       50
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       51
       +
                     <span>When someone creates an issue on your repository.</span>

     

       52
       +
                   </div>

     

       53
       +
                 </div>

     

       54
       +
               </div>

     

       55
       +
               <label class="flex items-center gap-2">

     

       56
       +
                 <input type="checkbox" name="issue_created" {{if .Preferences.IssueCreated}}checked{{end}}>

     

       57
       +
               </label>

     

       58
       +
             </div>

     

       59
       +
       

     

       60
       +
             <div class="flex items-center justify-between p-2">

     

       61
       +
               <div class="flex items-center gap-2">

     

       62
       +
                 <div class="flex flex-col gap-1">

     

       63
       +
                   <span class="font-bold">Issue comments</span>

     

       64
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       65
       +
                     <span>When someone comments on an issue you're involved with.</span>

     

       66
       +
                   </div>

     

       67
       +
                 </div>

     

       68
       +
               </div>

     

       69
       +
               <label class="flex items-center gap-2">

     

       70
       +
                 <input type="checkbox" name="issue_commented" {{if .Preferences.IssueCommented}}checked{{end}}>

     

       71
       +
               </label>

     

       72
       +
             </div>

     

       73
       +
       

     

       74
       +
             <div class="flex items-center justify-between p-2">

     

       75
       +
               <div class="flex items-center gap-2">

     

       76
       +
                 <div class="flex flex-col gap-1">

     

       77
       +
                   <span class="font-bold">Issue closed</span>

     

       78
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       79
       +
                     <span>When an issue on your repository is closed.</span>

     

       80
       +
                   </div>

     

       81
       +
                 </div>

     

       82
       +
               </div>

     

       83
       +
               <label class="flex items-center gap-2">

     

       84
       +
                 <input type="checkbox" name="issue_closed" {{if .Preferences.IssueClosed}}checked{{end}}>

     

       85
       +
               </label>

     

       86
       +
             </div>

     

       87
       +
       

     

       88
       +
             <div class="flex items-center justify-between p-2">

     

       89
       +
               <div class="flex items-center gap-2">

     

       90
       +
                 <div class="flex flex-col gap-1">

     

       91
       +
                   <span class="font-bold">New pull requests</span>

     

       92
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       93
       +
                     <span>When someone creates a pull request on your repository.</span>

     

       94
       +
                   </div>

     

       95
       +
                 </div>

     

       96
       +
               </div>

     

       97
       +
               <label class="flex items-center gap-2">

     

       98
       +
                 <input type="checkbox" name="pull_created" {{if .Preferences.PullCreated}}checked{{end}}>

     

       99
       +
               </label>

     

       100
       +
             </div>

     

       101
       +
       

     

       102
       +
             <div class="flex items-center justify-between p-2">

     

       103
       +
               <div class="flex items-center gap-2">

     

       104
       +
                 <div class="flex flex-col gap-1">

     

       105
       +
                   <span class="font-bold">Pull request comments</span>

     

       106
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       107
       +
                     <span>When someone comments on a pull request you're involved with.</span>

     

       108
       +
                   </div>

     

       109
       +
                 </div>

     

       110
       +
               </div>

     

       111
       +
               <label class="flex items-center gap-2">

     

       112
       +
                 <input type="checkbox" name="pull_commented" {{if .Preferences.PullCommented}}checked{{end}}>

     

       113
       +
               </label>

     

       114
       +
             </div>

     

       115
       +
       

     

       116
       +
             <div class="flex items-center justify-between p-2">

     

       117
       +
               <div class="flex items-center gap-2">

     

       118
       +
                 <div class="flex flex-col gap-1">

     

       119
       +
                   <span class="font-bold">Pull request merged</span>

     

       120
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       121
       +
                     <span>When your pull request is merged.</span>

     

       122
       +
                   </div>

     

       123
       +
                 </div>

     

       124
       +
               </div>

     

       125
       +
               <label class="flex items-center gap-2">

     

       126
       +
                 <input type="checkbox" name="pull_merged" {{if .Preferences.PullMerged}}checked{{end}}>

     

       127
       +
               </label>

     

       128
       +
             </div>

     

       129
       +
       

     

       130
       +
             <div class="flex items-center justify-between p-2">

     

       131
       +
               <div class="flex items-center gap-2">

     

       132
       +
                 <div class="flex flex-col gap-1">

     

       133
       +
                   <span class="font-bold">New followers</span>

     

       134
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       135
       +
                     <span>When someone follows you.</span>

     

       136
       +
                   </div>

     

       137
       +
                 </div>

     

       138
       +
               </div>

     

       139
       +
               <label class="flex items-center gap-2">

     

       140
       +
                 <input type="checkbox" name="followed" {{if .Preferences.Followed}}checked{{end}}>

     

       141
       +
               </label>

     

       142
       +
             </div>

     

       143
       +
       

     

       144
       +
             <div class="flex items-center justify-between p-2">

     

       145
       +
               <div class="flex items-center gap-2">

     

       146
       +
                 <div class="flex flex-col gap-1">

     

       147
       +
                   <span class="font-bold">Email notifications</span>

     

       148
       +
                   <div class="flex text-sm items-center gap-1 text-gray-500 dark:text-gray-400">

     

       149
       +
                     <span>Receive notifications via email in addition to in-app notifications.</span>

     

       150
       +
                   </div>

     

       151
       +
                 </div>

     

       152
       +
               </div>

     

       153
       +
               <label class="flex items-center gap-2">

     

       154
       +
                 <input type="checkbox" name="email_notifications" {{if .Preferences.EmailNotifications}}checked{{end}}>

     

       155
       +
               </label>

     

       156
       +
             </div>

     

       157
       +
           </div>

     

       158
       +
       

     

       159
       +
           <div class="flex justify-end pt-2">

     

       160
       +
             <button

     

       161
       +
               type="submit"

     

       162
       +
               class="btn-create flex items-center gap-2 group"

     

       163
       +
             >

     

       164
       +
               {{ i "save" "w-4 h-4" }}

     

       165
       +
               save

     

       166
       +
               {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       167
       +
             </button>

     

       168
       +
           </div>

     

       169
       +
           <div id="settings-notifications-success"></div>

     

       170
       +
       

     

       171
       +
           <div id="settings-notifications-error" class="error"></div>

     

       172
       +
         </form>

     

       173
       +
       {{ end }}

+13 -4

appview/pages/templates/layouts/fragments/topbar.html

···

       2
        
           <nav class="space-x-4 px-6 py-2 rounded-b bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm">

     

       3
        
               <div class="flex justify-between p-0 items-center">

     

       4
        
                   <div id="left-items">

     

       5
       -
                     <a href="/" hx-boost="true" class="text-2xl no-underline hover:no-underline">

     

       6
       -
                       {{ template "fragments/logotypeSmall" }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
                     </a>

     

       8
        
                   </div>

     

       9
        
       

     
···

       27
        
       {{ define "newButton" }}

     

       28
        
       <details class="relative inline-block text-left nav-dropdown">

     

       29
        
           <summary class="btn-create py-0 cursor-pointer list-none flex items-center gap-2">

     

       30
       -
             {{ i "plus" "w-4 h-4" }} new

     

       31
        
           </summary>

     

       32
        
           <div class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700">

     

       33
        
               <a href="/repo/new" class="flex items-center gap-2">

     
···

       48
        
               class="cursor-pointer list-none flex items-center gap-1"

     

       49
        
           >

     

       50
        
               {{ $user := didOrHandle .Did .Handle }}

     

       51
       -
               {{ template "user/fragments/picHandle" $user }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       52
        
           </summary>

     

       53
        
           <div

     

       54
        
               class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700"

···

       2
        
           <nav class="space-x-4 px-6 py-2 rounded-b bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm">

     

       3
        
               <div class="flex justify-between p-0 items-center">

     

       4
        
                   <div id="left-items">

     

       5
       +
                     <a href="/" hx-boost="true" class="text-2xl no-underline hover:no-underline flex items-center gap-2">

     

       6
       +
                       {{ template "fragments/dolly/logo" "size-8 text-black dark:text-white" }}

     

       7
       +
                       <span class="font-bold text-xl not-italic hidden md:inline">tangled</span>

     

       8
       +
                       <span class="font-normal not-italic text-xs rounded bg-gray-100 dark:bg-gray-700 px-1 hidden md:inline">

     

       9
       +
                         alpha

     

       10
       +
                       </span>

     

       11
        
                     </a>

     

       12
        
                   </div>

     

       13
        
       

     
···

       31
        
       {{ define "newButton" }}

     

       32
        
       <details class="relative inline-block text-left nav-dropdown">

     

       33
        
           <summary class="btn-create py-0 cursor-pointer list-none flex items-center gap-2">

     

       34
       +
             {{ i "plus" "w-4 h-4" }} <span class="hidden md:inline">new</span>

     

       35
        
           </summary>

     

       36
        
           <div class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700">

     

       37
        
               <a href="/repo/new" class="flex items-center gap-2">

     
···

       52
        
               class="cursor-pointer list-none flex items-center gap-1"

     

       53
        
           >

     

       54
        
               {{ $user := didOrHandle .Did .Handle }}

     

       55
       +
               <img

     

       56
       +
                   src="{{ tinyAvatar $user }}"

     

       57
       +
                   alt=""

     

       58
       +
                   class="rounded-full h-6 w-6 border border-gray-300 dark:border-gray-700"

     

       59
       +
               />

     

       60
       +
               <span class="hidden md:inline">{{ $user | resolve | truncateAt30 }}</span>

     

       61
        
           </summary>

     

       62
        
           <div

     

       63
        
               class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700"

+2 -2

appview/pages/templates/strings/put.html

···

       3
        
       {{ define "content" }}

     

       4
        
         <div class="px-6 py-2 mb-4">

     

       5
        
           {{ if eq .Action "new" }}

     

       6
       -
             <p class="text-xl font-bold dark:text-white">Create a new string</p>

     

       7
       -
             <p class="">Store and share code snippets with ease.</p>

     

       8
        
           {{ else }}

     

       9
        
             <p class="text-xl font-bold dark:text-white">Edit string</p>

     

       10
        
           {{ end }}

···

       3
        
       {{ define "content" }}

     

       4
        
         <div class="px-6 py-2 mb-4">

     

       5
        
           {{ if eq .Action "new" }}

     

       6
       +
             <p class="text-xl font-bold dark:text-white mb-1">Create a new string</p>

     

       7
       +
             <p class="text-gray-600 dark:text-gray-400 mb-1">Store and share code snippets with ease.</p>

     

       8
        
           {{ else }}

     

       9
        
             <p class="text-xl font-bold dark:text-white">Edit string</p>

     

       10
        
           {{ end }}

+4 -1

appview/validator/validator.go

···

       4
        
       	"tangled.org/core/appview/db"

     

       5
        
       	"tangled.org/core/appview/pages/markup"

     

       6
        
       	"tangled.org/core/idresolver"

     

       0
        
       
     

       7
        
       )

     

       8
        
       

     

       9
        
       type Validator struct {

     

       10
        
       	db        *db.DB

     

       11
        
       	sanitizer markup.Sanitizer

     

       12
        
       	resolver  *idresolver.Resolver

     

       0
        
       
     

       13
        
       }

     

       14
        
       

     

       15
       -
       func New(db *db.DB, res *idresolver.Resolver) *Validator {

     

       16
        
       	return &Validator{

     

       17
        
       		db:        db,

     

       18
        
       		sanitizer: markup.NewSanitizer(),

     

       19
        
       		resolver:  res,

     

       0
        
       
     

       20
        
       	}

     

       21
        
       }

···

       4
        
       	"tangled.org/core/appview/db"

     

       5
        
       	"tangled.org/core/appview/pages/markup"

     

       6
        
       	"tangled.org/core/idresolver"

     

       7
       +
       	"tangled.org/core/rbac"

     

       8
        
       )

     

       9
        
       

     

       10
        
       type Validator struct {

     

       11
        
       	db        *db.DB

     

       12
        
       	sanitizer markup.Sanitizer

     

       13
        
       	resolver  *idresolver.Resolver

     

       14
       +
       	enforcer  *rbac.Enforcer

     

       15
        
       }

     

       16
        
       

     

       17
       +
       func New(db *db.DB, res *idresolver.Resolver, enforcer *rbac.Enforcer) *Validator {

     

       18
        
       	return &Validator{

     

       19
        
       		db:        db,

     

       20
        
       		sanitizer: markup.NewSanitizer(),

     

       21
        
       		resolver:  res,

     

       22
       +
       		enforcer:  enforcer,

     

       23
        
       	}

     

       24
        
       }

+5 -4

appview/models/label.go

···

       232
        
       	}

     

       233
        
       

     

       234
        
       	var ops []LabelOp

     

       235
       -
       	for _, o := range record.Add {

     

       0
        
       
     

       236
        
       		if o != nil {

     

       237
        
       			op := mkOp(o)

     

       238
       -
       			op.Operation = LabelOperationAdd

     

       239
        
       			ops = append(ops, op)

     

       240
        
       		}

     

       241
        
       	}

     

       242
       -
       	for _, o := range record.Delete {

     

       243
        
       		if o != nil {

     

       244
        
       			op := mkOp(o)

     

       245
       -
       			op.Operation = LabelOperationDel

     

       246
        
       			ops = append(ops, op)

     

       247
        
       		}

     

       248
        
       	}

···

       232
        
       	}

     

       233
        
       

     

       234
        
       	var ops []LabelOp

     

       235
       +
       	// deletes first, then additions

     

       236
       +
       	for _, o := range record.Delete {

     

       237
        
       		if o != nil {

     

       238
        
       			op := mkOp(o)

     

       239
       +
       			op.Operation = LabelOperationDel

     

       240
        
       			ops = append(ops, op)

     

       241
        
       		}

     

       242
        
       	}

     

       243
       +
       	for _, o := range record.Add {

     

       244
        
       		if o != nil {

     

       245
        
       			op := mkOp(o)

     

       246
       +
       			op.Operation = LabelOperationAdd

     

       247
        
       			ops = append(ops, op)

     

       248
        
       		}

     

       249
        
       	}

+1 -1

knotserver/xrpc/repo_blob.go

···

       44
        
       

     

       45
        
       	contents, err := gr.RawContent(treePath)

     

       46
        
       	if err != nil {

     

       47
       -
       		x.Logger.Error("file content", "error", err.Error())

     

       48
        
       		writeError(w, xrpcerr.NewXrpcError(

     

       49
        
       			xrpcerr.WithTag("FileNotFound"),

     

       50
        
       			xrpcerr.WithMessage("file not found at the specified path"),

···

       44
        
       

     

       45
        
       	contents, err := gr.RawContent(treePath)

     

       46
        
       	if err != nil {

     

       47
       +
       		x.Logger.Error("file content", "error", err.Error(), "treePath", treePath)

     

       48
        
       		writeError(w, xrpcerr.NewXrpcError(

     

       49
        
       			xrpcerr.WithTag("FileNotFound"),

     

       50
        
       			xrpcerr.WithMessage("file not found at the specified path"),

+7 -5

types/repo.go

···

       41
        
       }

     

       42
        
       

     

       43
        
       type RepoTreeResponse struct {

     

       44
       -
       	Ref         string     `json:"ref,omitempty"`

     

       45
       -
       	Parent      string     `json:"parent,omitempty"`

     

       46
       -
       	Description string     `json:"description,omitempty"`

     

       47
       -
       	DotDot      string     `json:"dotdot,omitempty"`

     

       48
       -
       	Files       []NiceTree `json:"files,omitempty"`

     

       0
        
       
     

       0
        
       
     

       49
        
       }

     

       50
        
       

     

       51
        
       type TagReference struct {

···

       41
        
       }

     

       42
        
       

     

       43
        
       type RepoTreeResponse struct {

     

       44
       +
       	Ref            string     `json:"ref,omitempty"`

     

       45
       +
       	Parent         string     `json:"parent,omitempty"`

     

       46
       +
       	Description    string     `json:"description,omitempty"`

     

       47
       +
       	DotDot         string     `json:"dotdot,omitempty"`

     

       48
       +
       	Files          []NiceTree `json:"files,omitempty"`

     

       49
       +
       	ReadmeFileName string     `json:"readme_filename,omitempty"`

     

       50
       +
       	Readme         string     `json:"readme_contents,omitempty"`

     

       51
        
       }

     

       52
        
       

     

       53
        
       type TagReference struct {

+224

appview/pages/templates/brand/brand.html

···

       1
       +
       {{ define "title" }}brand{{ end }}

     

       2
       +
       

     

       3
       +
       {{ define "content" }}

     

       4
       +
       <div class="grid grid-cols-10">

     

       5
       +
         <header class="col-span-full md:col-span-10 px-6 py-2 mb-4">

     

       6
       +
           <h1 class="text-2xl font-bold dark:text-white mb-1">Brand</h1>

     

       7
       +
           <p class="text-gray-600 dark:text-gray-400 mb-1">

     

       8
       +
           Assets and guidelines for using Tangled's logo and brand elements.

     

       9
       +
           </p>

     

       10
       +
         </header>

     

       11
       +
       

     

       12
       +
         <main class="col-span-full md:col-span-10 bg-white dark:bg-gray-800 drop-shadow-sm rounded p-6 md:px-10">

     

       13
       +
           <div class="space-y-16">

     

       14
       +
       

     

       15
       +
             <!-- Introduction Section -->

     

       16
       +
             <section>

     

       17
       +
               <p class="text-gray-600 dark:text-gray-400 mb-2">

     

       18
       +
               Tangled's logo and mascot is <strong>Dolly</strong>, the first ever <em>cloned</em> mammal. Please

     

       19
       +
               follow the below guidelines when using Dolly and the logotype.

     

       20
       +
               </p>

     

       21
       +
               <p class="text-gray-600 dark:text-gray-400 mb-2">

     

       22
       +
               All assets are served as SVGs, and can be downloaded by right-clicking and clicking "Save image as".

     

       23
       +
               </p>

     

       24
       +
             </section>

     

       25
       +
       

     

       26
       +
             <!-- Black Logotype Section -->

     

       27
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       28
       +
               <div class="order-2 lg:order-1">

     

       29
       +
                 <div class="border border-gray-200 dark:border-gray-700 p-8 sm:p-16 bg-gray-50 dark:bg-gray-100 rounded">

     

       30
       +
                   <img src="https://assets.tangled.network/tangled_logotype_black_on_trans.svg"

     

       31
       +
                        alt="Tangled logo - black version"

     

       32
       +
                        class="w-full max-w-sm mx-auto" />

     

       33
       +
                 </div>

     

       34
       +
               </div>

     

       35
       +
               <div class="order-1 lg:order-2">

     

       36
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Black logotype</h2>

     

       37
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">For use on light-colored backgrounds.</p>

     

       38
       +
                 <p class="text-gray-700 dark:text-gray-300">

     

       39
       +
                 This is the preferred version of the logotype, featuring dark text and elements, ideal for light

     

       40
       +
                 backgrounds and designs.

     

       41
       +
                 </p>

     

       42
       +
               </div>

     

       43
       +
             </section>

     

       44
       +
       

     

       45
       +
             <!-- White Logotype Section -->

     

       46
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       47
       +
               <div class="order-2 lg:order-1">

     

       48
       +
                 <div class="bg-black p-8 sm:p-16 rounded">

     

       49
       +
                   <img src="https://assets.tangled.network/tangled_logotype_white_on_trans.svg"

     

       50
       +
                        alt="Tangled logo - white version"

     

       51
       +
                        class="w-full max-w-sm mx-auto" />

     

       52
       +
                 </div>

     

       53
       +
               </div>

     

       54
       +
               <div class="order-1 lg:order-2">

     

       55
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">White logotype</h2>

     

       56
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">For use on dark-colored backgrounds.</p>

     

       57
       +
                 <p class="text-gray-700 dark:text-gray-300">

     

       58
       +
                   This version features white text and elements, ideal for dark backgrounds

     

       59
       +
                   and inverted designs.

     

       60
       +
                 </p>

     

       61
       +
               </div>

     

       62
       +
             </section>

     

       63
       +
       

     

       64
       +
             <!-- Mark Only Section -->

     

       65
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       66
       +
               <div class="order-2 lg:order-1">

     

       67
       +
                 <div class="grid grid-cols-2 gap-2">

     

       68
       +
                   <!-- Black mark on light background -->

     

       69
       +
                   <div class="border border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-100 p-8 sm:p-12 rounded">

     

       70
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_black_on_trans.svg"

     

       71
       +
                          alt="Dolly face - black version"

     

       72
       +
                          class="w-full max-w-16 mx-auto" />

     

       73
       +
                   </div>

     

       74
       +
                   <!-- White mark on dark background -->

     

       75
       +
                   <div class="bg-black p-8 sm:p-12 rounded">

     

       76
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_white_on_trans.svg"

     

       77
       +
                          alt="Dolly face - white version"

     

       78
       +
                          class="w-full max-w-16 mx-auto" />

     

       79
       +
                   </div>

     

       80
       +
                 </div>

     

       81
       +
               </div>

     

       82
       +
               <div class="order-1 lg:order-2">

     

       83
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Mark only</h2>

     

       84
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">

     

       85
       +
                   When a smaller 1:1 logo or icon is needed, Dolly's face may be used on its own.

     

       86
       +
                 </p>

     

       87
       +
                 <p class="text-gray-700 dark:text-gray-300 mb-4">

     

       88
       +
                   <strong class="font-semibold">Note</strong>: for situations where the background

     

       89
       +
                   is unknown, use the black version for ideal contrast in most environments.

     

       90
       +
                 </p>

     

       91
       +
               </div>

     

       92
       +
             </section>

     

       93
       +
       

     

       94
       +
             <!-- Colored Backgrounds Section -->

     

       95
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       96
       +
               <div class="order-2 lg:order-1">

     

       97
       +
                 <div class="grid grid-cols-2 gap-2">

     

       98
       +
                   <!-- Pastel Green background -->

     

       99
       +
                   <div class="bg-green-500 p-8 sm:p-12 rounded">

     

       100
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_white_on_trans.svg"

     

       101
       +
                          alt="Tangled logo on pastel green background"

     

       102
       +
                          class="w-full max-w-16 mx-auto" />

     

       103
       +
                   </div>

     

       104
       +
                   <!-- Pastel Blue background -->

     

       105
       +
                   <div class="bg-blue-500 p-8 sm:p-12 rounded">

     

       106
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_white_on_trans.svg"

     

       107
       +
                          alt="Tangled logo on pastel blue background"

     

       108
       +
                          class="w-full max-w-16 mx-auto" />

     

       109
       +
                   </div>

     

       110
       +
                   <!-- Pastel Yellow background -->

     

       111
       +
                   <div class="bg-yellow-500 p-8 sm:p-12 rounded">

     

       112
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_white_on_trans.svg"

     

       113
       +
                          alt="Tangled logo on pastel yellow background"

     

       114
       +
                          class="w-full max-w-16 mx-auto" />

     

       115
       +
                   </div>

     

       116
       +
                   <!-- Pastel Red background -->

     

       117
       +
                   <div class="bg-red-500 p-8 sm:p-12 rounded">

     

       118
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_white_on_trans.svg"

     

       119
       +
                          alt="Tangled logo on pastel red background"

     

       120
       +
                          class="w-full max-w-16 mx-auto" />

     

       121
       +
                   </div>

     

       122
       +
                 </div>

     

       123
       +
               </div>

     

       124
       +
               <div class="order-1 lg:order-2">

     

       125
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Colored backgrounds</h2>

     

       126
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">

     

       127
       +
                   White logo mark on colored backgrounds.

     

       128
       +
                 </p>

     

       129
       +
                 <p class="text-gray-700 dark:text-gray-300 mb-4">

     

       130
       +
                   The white logo mark provides contrast on colored backgrounds.

     

       131
       +
                   Perfect for more fun design contexts.

     

       132
       +
                 </p>

     

       133
       +
               </div>

     

       134
       +
             </section>

     

       135
       +
       

     

       136
       +
             <!-- Black Logo on Pastel Backgrounds Section -->

     

       137
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       138
       +
               <div class="order-2 lg:order-1">

     

       139
       +
                 <div class="grid grid-cols-2 gap-2">

     

       140
       +
                   <!-- Pastel Green background -->

     

       141
       +
                   <div class="bg-green-200 p-8 sm:p-12 rounded">

     

       142
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_black_on_trans.svg"

     

       143
       +
                          alt="Tangled logo on pastel green background"

     

       144
       +
                          class="w-full max-w-16 mx-auto" />

     

       145
       +
                   </div>

     

       146
       +
                   <!-- Pastel Blue background -->

     

       147
       +
                   <div class="bg-blue-200 p-8 sm:p-12 rounded">

     

       148
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_black_on_trans.svg"

     

       149
       +
                          alt="Tangled logo on pastel blue background"

     

       150
       +
                          class="w-full max-w-16 mx-auto" />

     

       151
       +
                   </div>

     

       152
       +
                   <!-- Pastel Yellow background -->

     

       153
       +
                   <div class="bg-yellow-200 p-8 sm:p-12 rounded">

     

       154
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_black_on_trans.svg"

     

       155
       +
                          alt="Tangled logo on pastel yellow background"

     

       156
       +
                          class="w-full max-w-16 mx-auto" />

     

       157
       +
                   </div>

     

       158
       +
                   <!-- Pastel Pink background -->

     

       159
       +
                   <div class="bg-pink-200 p-8 sm:p-12 rounded">

     

       160
       +
                     <img src="https://assets.tangled.network/tangled_dolly_face_only_black_on_trans.svg"

     

       161
       +
                          alt="Tangled logo on pastel pink background"

     

       162
       +
                          class="w-full max-w-16 mx-auto" />

     

       163
       +
                   </div>

     

       164
       +
                 </div>

     

       165
       +
               </div>

     

       166
       +
               <div class="order-1 lg:order-2">

     

       167
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Lighter backgrounds</h2>

     

       168
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">

     

       169
       +
                   Dark logo mark on lighter, pastel backgrounds.

     

       170
       +
                 </p>

     

       171
       +
                 <p class="text-gray-700 dark:text-gray-300 mb-4">

     

       172
       +
                   The dark logo mark works beautifully on pastel backgrounds,

     

       173
       +
                   providing crisp contrast.

     

       174
       +
                 </p>

     

       175
       +
               </div>

     

       176
       +
             </section>

     

       177
       +
       

     

       178
       +
             <!-- Recoloring Section -->

     

       179
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       180
       +
               <div class="order-2 lg:order-1">

     

       181
       +
                 <div class="bg-yellow-100 border border-yellow-200 p-8 sm:p-16 rounded">

     

       182
       +
                   <img src="https://assets.tangled.network/tangled_logotype_black_on_trans.svg"

     

       183
       +
                        alt="Recolored Tangled logotype in gray/sand color"

     

       184
       +
                        class="w-full max-w-sm mx-auto opacity-60 sepia contrast-75 saturate-50" />

     

       185
       +
                 </div>

     

       186
       +
               </div>

     

       187
       +
               <div class="order-1 lg:order-2">

     

       188
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Recoloring</h2>

     

       189
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">

     

       190
       +
                   Custom coloring of the logotype is permitted.

     

       191
       +
                 </p>

     

       192
       +
                 <p class="text-gray-700 dark:text-gray-300 mb-4">

     

       193
       +
                   Recoloring the logotype is allowed as long as readability is maintained.

     

       194
       +
                 </p>

     

       195
       +
                 <p class="text-gray-700 dark:text-gray-300 text-sm">

     

       196
       +
                   <strong>Example:</strong> Gray/sand colored logotype on a light yellow/tan background.

     

       197
       +
                 </p>

     

       198
       +
               </div>

     

       199
       +
             </section>

     

       200
       +
       

     

       201
       +
             <!-- Silhouette Section -->

     

       202
       +
             <section class="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">

     

       203
       +
               <div class="order-2 lg:order-1">

     

       204
       +
                 <div class="border border-gray-200 dark:border-gray-700 p-8 sm:p-16 bg-gray-50 dark:bg-gray-100 rounded">

     

       205
       +
                   <img src="https://assets.tangled.network/tangled_dolly_silhouette.svg"

     

       206
       +
                        alt="Dolly silhouette"

     

       207
       +
                        class="w-full max-w-32 mx-auto" />

     

       208
       +
                 </div>

     

       209
       +
               </div>

     

       210
       +
               <div class="order-1 lg:order-2">

     

       211
       +
                 <h2 class="text-xl font-semibold dark:text-white mb-3">Dolly silhouette</h2>

     

       212
       +
                 <p class="text-gray-600 dark:text-gray-400 mb-4">A minimalist version of Dolly.</p>

     

       213
       +
                 <p class="text-gray-700 dark:text-gray-300">

     

       214
       +
                   The silhouette can be used where a subtle brand presence is needed,

     

       215
       +
                   or as a background element. Works on any background color with proper contrast.

     

       216
       +
                   For example, we use this as the site's favicon.

     

       217
       +
                 </p>

     

       218
       +
               </div>

     

       219
       +
             </section>

     

       220
       +
       

     

       221
       +
           </div>

     

       222
       +
         </main>

     

       223
       +
       </div>

     

       224
       +
       {{ end }}

+1 -1

appview/pages/templates/user/fragments/followCard.html

···

       1
        
       {{ define "user/fragments/followCard" }}

     

       2
        
       {{ $userIdent := resolve .UserDid }}

     

       3
       -
       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       4
        
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4">

     

       5
        
           <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       6
        
             <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" />

···

       1
        
       {{ define "user/fragments/followCard" }}

     

       2
        
       {{ $userIdent := resolve .UserDid }}

     

       3
       +
       <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 rounded-sm">

     

       4
        
         <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4">

     

       5
        
           <div class="flex-shrink-0 max-h-full w-24 h-24">

     

       6
        
             <img class="object-cover rounded-full p-2" src="{{ fullAvatar $userIdent }}" />

+4 -2

appview/config/config.go

···

       72
        
       }

     

       73
        
       

     

       74
        
       type Cloudflare struct {

     

       75
       -
       	ApiToken string `env:"API_TOKEN"`

     

       76
       -
       	ZoneId   string `env:"ZONE_ID"`

     

       0
        
       
     

       0
        
       
     

       77
        
       }

     

       78
        
       

     

       79
        
       func (cfg RedisConfig) ToURL() string {

···

       72
        
       }

     

       73
        
       

     

       74
        
       type Cloudflare struct {

     

       75
       +
       	ApiToken           string `env:"API_TOKEN"`

     

       76
       +
       	ZoneId             string `env:"ZONE_ID"`

     

       77
       +
       	TurnstileSiteKey   string `env:"TURNSTILE_SITE_KEY"`

     

       78
       +
       	TurnstileSecretKey string `env:"TURNSTILE_SECRET_KEY"`

     

       79
        
       }

     

       80
        
       

     

       81
        
       func (cfg RedisConfig) ToURL() string {

+13 -9

appview/db/email.go

···

       71
        
       	return did, nil

     

       72
        
       }

     

       73
        
       

     

       74
       -
       func GetEmailToDid(e Execer, ems []string, isVerifiedFilter bool) (map[string]string, error) {

     

       75
       -
       	if len(ems) == 0 {

     

       76
        
       		return make(map[string]string), nil

     

       77
        
       	}

     

       78
        
       

     
···

       81
        
       		verifiedFilter = 1

     

       82
        
       	}

     

       83
        
       

     

       0
        
       
     

       0
        
       
     

       84
        
       	// Create placeholders for the IN clause

     

       85
       -
       	placeholders := make([]string, len(ems))

     

       86
       -
       	args := make([]any, len(ems)+1)

     

       87
        
       

     

       88
        
       	args[0] = verifiedFilter

     

       89
       -
       	for i, em := range ems {

     

       90
       -
       		placeholders[i] = "?"

     

       91
       -
       		args[i+1] = em

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       92
        
       	}

     

       93
        
       

     

       94
        
       	query := `

     
···

       105
        
       	}

     

       106
        
       	defer rows.Close()

     

       107
        
       

     

       108
       -
       	assoc := make(map[string]string)

     

       109
       -
       

     

       110
        
       	for rows.Next() {

     

       111
        
       		var email, did string

     

       112
        
       		if err := rows.Scan(&email, &did); err != nil {

···

       71
        
       	return did, nil

     

       72
        
       }

     

       73
        
       

     

       74
       +
       func GetEmailToDid(e Execer, emails []string, isVerifiedFilter bool) (map[string]string, error) {

     

       75
       +
       	if len(emails) == 0 {

     

       76
        
       		return make(map[string]string), nil

     

       77
        
       	}

     

       78
        
       

     
···

       81
        
       		verifiedFilter = 1

     

       82
        
       	}

     

       83
        
       

     

       84
       +
       	assoc := make(map[string]string)

     

       85
       +
       

     

       86
        
       	// Create placeholders for the IN clause

     

       87
       +
       	placeholders := make([]string, 0, len(emails))

     

       88
       +
       	args := make([]any, 1, len(emails)+1)

     

       89
        
       

     

       90
        
       	args[0] = verifiedFilter

     

       91
       +
       	for _, email := range emails {

     

       92
       +
       		if strings.HasPrefix(email, "did:") {

     

       93
       +
       			assoc[email] = email

     

       94
       +
       			continue

     

       95
       +
       		}

     

       96
       +
       		placeholders = append(placeholders, "?")

     

       97
       +
       		args = append(args, email)

     

       98
        
       	}

     

       99
        
       

     

       100
        
       	query := `

     
···

       111
        
       	}

     

       112
        
       	defer rows.Close()

     

       113
        
       

     

       0
        
       
     

       0
        
       
     

       114
        
       	for rows.Next() {

     

       115
        
       		var email, did string

     

       116
        
       		if err := rows.Scan(&email, &did); err != nil {

+140

appview/db/db.go

···

       954
        
       		return err

     

       955
        
       	})

     

       956
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       957
        
       	return &DB{db}, nil

     

       958
        
       }

     

       959

···

       954
        
       		return err

     

       955
        
       	})

     

       956
        
       

     

       957
       +
       	// add generated at_uri column to pulls table

     

       958
       +
       	//

     

       959
       +
       	// this requires a full table recreation because stored columns

     

       960
       +
       	// cannot be added via alter

     

       961
       +
       	//

     

       962
       +
       	// disable foreign-keys for the next migration

     

       963
       +
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       964
       +
       	runMigration(conn, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       965
       +
       		_, err := tx.Exec(`

     

       966
       +
       		create table if not exists pulls_new (

     

       967
       +
       			-- identifiers

     

       968
       +
       			id integer primary key autoincrement,

     

       969
       +
       			pull_id integer not null,

     

       970
       +
       			at_uri text generated always as ('at://' || owner_did || '/' || 'sh.tangled.repo.pull' || '/' || rkey) stored,

     

       971
       +
       

     

       972
       +
       			-- at identifiers

     

       973
       +
       			repo_at text not null,

     

       974
       +
       			owner_did text not null,

     

       975
       +
       			rkey text not null,

     

       976
       +
       

     

       977
       +
       			-- content

     

       978
       +
       			title text not null,

     

       979
       +
       			body text not null,

     

       980
       +
       			target_branch text not null,

     

       981
       +
       			state integer not null default 0 check (state in (0, 1, 2, 3)), -- closed, open, merged, deleted

     

       982
       +
       

     

       983
       +
       			-- source info

     

       984
       +
       			source_branch text,

     

       985
       +
       			source_repo_at text,

     

       986
       +
       

     

       987
       +
       			-- stacking

     

       988
       +
       			stack_id text,

     

       989
       +
       			change_id text,

     

       990
       +
       			parent_change_id text,

     

       991
       +
       

     

       992
       +
       			-- meta

     

       993
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       994
       +
       

     

       995
       +
       			-- constraints

     

       996
       +
       			unique(repo_at, pull_id),

     

       997
       +
       			unique(at_uri),

     

       998
       +
       			foreign key (repo_at) references repos(at_uri) on delete cascade

     

       999
       +
       		);

     

       1000
       +
       		`)

     

       1001
       +
       		if err != nil {

     

       1002
       +
       			return err

     

       1003
       +
       		}

     

       1004
       +
       

     

       1005
       +
       		// transfer data

     

       1006
       +
       		_, err = tx.Exec(`

     

       1007
       +
       		insert into pulls_new (

     

       1008
       +
       			id, pull_id, repo_at, owner_did, rkey,

     

       1009
       +
       			title, body, target_branch, state,

     

       1010
       +
       			source_branch, source_repo_at,

     

       1011
       +
       			stack_id, change_id, parent_change_id,

     

       1012
       +
       			created

     

       1013
       +
       		)

     

       1014
       +
       		select

     

       1015
       +
       			id, pull_id, repo_at, owner_did, rkey,

     

       1016
       +
       			title, body, target_branch, state,

     

       1017
       +
       			source_branch, source_repo_at,

     

       1018
       +
       			stack_id, change_id, parent_change_id,

     

       1019
       +
       			created

     

       1020
       +
       			from pulls;

     

       1021
       +
       		`)

     

       1022
       +
       		if err != nil {

     

       1023
       +
       			return err

     

       1024
       +
       		}

     

       1025
       +
       

     

       1026
       +
       		// drop old table

     

       1027
       +
       		_, err = tx.Exec(`drop table pulls`)

     

       1028
       +
       		if err != nil {

     

       1029
       +
       			return err

     

       1030
       +
       		}

     

       1031
       +
       

     

       1032
       +
       		// rename new table

     

       1033
       +
       		_, err = tx.Exec(`alter table pulls_new rename to pulls`)

     

       1034
       +
       		return err

     

       1035
       +
       	})

     

       1036
       +
       	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       1037
       +
       

     

       1038
       +
       	// remove repo_at and pull_id from pull_submissions and replace with pull_at

     

       1039
       +
       	//

     

       1040
       +
       	// this requires a full table recreation because stored columns

     

       1041
       +
       	// cannot be added via alter

     

       1042
       +
       	//

     

       1043
       +
       	// disable foreign-keys for the next migration

     

       1044
       +
       	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       1045
       +
       	runMigration(conn, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       1046
       +
       		_, err := tx.Exec(`

     

       1047
       +
       		create table if not exists pull_submissions_new (

     

       1048
       +
       			-- identifiers

     

       1049
       +
       			id integer primary key autoincrement,

     

       1050
       +
       			pull_at text not null,

     

       1051
       +
       

     

       1052
       +
       			-- content, these are immutable, and require a resubmission to update

     

       1053
       +
       			round_number integer not null default 0,

     

       1054
       +
       			patch text,

     

       1055
       +
       			source_rev text,

     

       1056
       +
       

     

       1057
       +
       			-- meta

     

       1058
       +
       			created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),

     

       1059
       +
       

     

       1060
       +
       			-- constraints

     

       1061
       +
       			unique(pull_at, round_number),

     

       1062
       +
       			foreign key (pull_at) references pulls(at_uri) on delete cascade

     

       1063
       +
       		);

     

       1064
       +
       		`)

     

       1065
       +
       		if err != nil {

     

       1066
       +
       			return err

     

       1067
       +
       		}

     

       1068
       +
       

     

       1069
       +
       		// transfer data, constructing pull_at from pulls table

     

       1070
       +
       		_, err = tx.Exec(`

     

       1071
       +
       		insert into pull_submissions_new (id, pull_at, round_number, patch, created)

     

       1072
       +
       		select 

     

       1073
       +
       			ps.id,

     

       1074
       +
       			'at://' || p.owner_did || '/sh.tangled.repo.pull/' || p.rkey,

     

       1075
       +
       			ps.round_number,

     

       1076
       +
       			ps.patch,

     

       1077
       +
       			ps.created

     

       1078
       +
       		from pull_submissions ps

     

       1079
       +
       		join pulls p on ps.repo_at = p.repo_at and ps.pull_id = p.pull_id;

     

       1080
       +
       		`)

     

       1081
       +
       		if err != nil {

     

       1082
       +
       			return err

     

       1083
       +
       		}

     

       1084
       +
       

     

       1085
       +
       		// drop old table

     

       1086
       +
       		_, err = tx.Exec(`drop table pull_submissions`)

     

       1087
       +
       		if err != nil {

     

       1088
       +
       			return err

     

       1089
       +
       		}

     

       1090
       +
       

     

       1091
       +
       		// rename new table

     

       1092
       +
       		_, err = tx.Exec(`alter table pull_submissions_new rename to pull_submissions`)

     

       1093
       +
       		return err

     

       1094
       +
       	})

     

       1095
       +
       	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       1096
       +
       

     

       1097
        
       	return &DB{db}, nil

     

       1098
        
       }

     

       1099

+5 -1

appview/issues/issues.go

···

       798
        
       		return

     

       799
        
       	}

     

       800
        
       

     

       801
       -
       	labelDefs, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       802
        
       	if err != nil {

     

       803
        
       		log.Println("failed to fetch labels", err)

     

       804
        
       		rp.pages.Error503(w)

···

       798
        
       		return

     

       799
        
       	}

     

       800
        
       

     

       801
       +
       	labelDefs, err := db.GetLabelDefinitions(

     

       802
       +
       		rp.db,

     

       803
       +
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       804
       +
       		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       805
       +
       	)

     

       806
        
       	if err != nil {

     

       807
        
       		log.Println("failed to fetch labels", err)

     

       808
        
       		rp.pages.Error503(w)

+44 -1

appview/models/pull.go

···

       77
        
       	PullSource *PullSource

     

       78
        
       

     

       79
        
       	// optionally, populate this when querying for reverse mappings

     

       80
       -
       	Repo *Repo

     

       0
        
       
     

       81
        
       }

     

       82
        
       

     

       83
        
       func (p Pull) AsRecord() tangled.RepoPull {

     
···

       206
        
       	return p.StackId != ""

     

       207
        
       }

     

       208
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       209
        
       func (s PullSubmission) IsFormatPatch() bool {

     

       210
        
       	return patchutil.IsFormatPatch(s.Patch)

     

       211
        
       }

     
···

       220
        
       	return patches

     

       221
        
       }

     

       222
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       223
        
       type Stack []*Pull

     

       224
        
       

     

       225
        
       // position of this pull in the stack

···

       77
        
       	PullSource *PullSource

     

       78
        
       

     

       79
        
       	// optionally, populate this when querying for reverse mappings

     

       80
       +
       	Labels LabelState

     

       81
       +
       	Repo   *Repo

     

       82
        
       }

     

       83
        
       

     

       84
        
       func (p Pull) AsRecord() tangled.RepoPull {

     
···

       207
        
       	return p.StackId != ""

     

       208
        
       }

     

       209
        
       

     

       210
       +
       func (p *Pull) Participants() []string {

     

       211
       +
       	participantSet := make(map[string]struct{})

     

       212
       +
       	participants := []string{}

     

       213
       +
       

     

       214
       +
       	addParticipant := func(did string) {

     

       215
       +
       		if _, exists := participantSet[did]; !exists {

     

       216
       +
       			participantSet[did] = struct{}{}

     

       217
       +
       			participants = append(participants, did)

     

       218
       +
       		}

     

       219
       +
       	}

     

       220
       +
       

     

       221
       +
       	addParticipant(p.OwnerDid)

     

       222
       +
       

     

       223
       +
       	for _, s := range p.Submissions {

     

       224
       +
       		for _, sp := range s.Participants() {

     

       225
       +
       			addParticipant(sp)

     

       226
       +
       		}

     

       227
       +
       	}

     

       228
       +
       

     

       229
       +
       	return participants

     

       230
       +
       }

     

       231
       +
       

     

       232
        
       func (s PullSubmission) IsFormatPatch() bool {

     

       233
        
       	return patchutil.IsFormatPatch(s.Patch)

     

       234
        
       }

     
···

       243
        
       	return patches

     

       244
        
       }

     

       245
        
       

     

       246
       +
       func (s *PullSubmission) Participants() []string {

     

       247
       +
       	participantSet := make(map[string]struct{})

     

       248
       +
       	participants := []string{}

     

       249
       +
       

     

       250
       +
       	addParticipant := func(did string) {

     

       251
       +
       		if _, exists := participantSet[did]; !exists {

     

       252
       +
       			participantSet[did] = struct{}{}

     

       253
       +
       			participants = append(participants, did)

     

       254
       +
       		}

     

       255
       +
       	}

     

       256
       +
       

     

       257
       +
       	addParticipant(s.PullAt.Authority().String())

     

       258
       +
       

     

       259
       +
       	for _, c := range s.Comments {

     

       260
       +
       		addParticipant(c.OwnerDid)

     

       261
       +
       	}

     

       262
       +
       

     

       263
       +
       	return participants

     

       264
       +
       }

     

       265
       +
       

     

       266
        
       type Stack []*Pull

     

       267
        
       

     

       268
        
       // position of this pull in the stack

+26

appview/pages/templates/repo/fragments/participants.html

···

       1
       +
       {{ define "repo/fragments/participants" }}

     

       2
       +
         {{ $all := . }}

     

       3
       +
         {{ $ps := take $all 5 }}

     

       4
       +
         <div class="px-6 md:px-0">

     

       5
       +
           <div class="py-1 flex items-center text-sm">

     

       6
       +
             <span class="font-bold text-gray-500 dark:text-gray-400 capitalize">Participants</span>

     

       7
       +
             <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 ml-1">{{ len $all }}</span>

     

       8
       +
           </div>

     

       9
       +
           <div class="flex items-center -space-x-3 mt-2">

     

       10
       +
             {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       11
       +
             {{ range $i, $p := $ps }}

     

       12
       +
               <img

     

       13
       +
                   src="{{ tinyAvatar . }}"

     

       14
       +
                   alt=""

     

       15
       +
                   class="rounded-full h-8 w-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0"

     

       16
       +
               />

     

       17
       +
             {{ end }}

     

       18
       +
       

     

       19
       +
             {{ if gt (len $all) 5 }}

     

       20
       +
               <span class="pl-4 text-gray-500 dark:text-gray-400 text-sm">

     

       21
       +
                 +{{ sub (len $all) 5 }}

     

       22
       +
               </span>

     

       23
       +
             {{ end }}

     

       24
       +
           </div>

     

       25
       +
         </div>

     

       26
       +
       {{ end }}

+1 -27

appview/pages/templates/repo/issues/issue.html

···

       22
        
                     "Defs" $.LabelDefs

     

       23
        
                     "Subject" $.Issue.AtUri

     

       24
        
                     "State" $.Issue.Labels) }}

     

       25
       -
             {{ template "issueParticipants" . }}

     

       26
        
           </div>

     

       27
        
         </div>

     

       28
        
       {{ end }}

     
···

       122
        
         </div>

     

       123
        
       {{ end }}

     

       124
        
       

     

       125
       -
       {{ define "issueParticipants" }}

     

       126
       -
         {{ $all := .Issue.Participants }}

     

       127
       -
         {{ $ps := take $all 5 }}

     

       128
       -
         <div>

     

       129
       -
           <div class="py-1 flex items-center text-sm">

     

       130
       -
             <span class="font-bold text-gray-500 dark:text-gray-400 capitalize">Participants</span>

     

       131
       -
             <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 ml-1">{{ len $all }}</span>

     

       132
       -
           </div>

     

       133
       -
           <div class="flex items-center -space-x-3 mt-2">

     

       134
       -
             {{ $c := "z-50 z-40 z-30 z-20 z-10" }}

     

       135
       -
             {{ range $i, $p := $ps }}

     

       136
       -
               <img

     

       137
       -
                   src="{{ tinyAvatar . }}"

     

       138
       -
                   alt=""

     

       139
       -
                   class="rounded-full h-8 w-8 mr-1 border-2 border-gray-100 dark:border-gray-900 z-{{sub 5 $i}}0"

     

       140
       -
               />

     

       141
       -
             {{ end }}

     

       142
       -
       

     

       143
       -
             {{ if gt (len $all) 5 }}

     

       144
       -
               <span class="pl-4 text-gray-500 dark:text-gray-400 text-sm">

     

       145
       -
                 +{{ sub (len $all) 5 }}

     

       146
       -
               </span>

     

       147
       -
             {{ end }}

     

       148
       -
           </div>

     

       149
       -
         </div>

     

       150
       -
       {{ end }}

     

       151
        
       

     

       152
        
       {{ define "repoAfter" }}

     

       153
        
         <div class="flex flex-col gap-4 mt-4">

···

       22
        
                     "Defs" $.LabelDefs

     

       23
        
                     "Subject" $.Issue.AtUri

     

       24
        
                     "State" $.Issue.Labels) }}

     

       25
       +
             {{ template "repo/fragments/participants" $.Issue.Participants }}

     

       26
        
           </div>

     

       27
        
         </div>

     

       28
        
       {{ end }}

     
···

       122
        
         </div>

     

       123
        
       {{ end }}

     

       124
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       125
        
       

     

       126
        
       {{ define "repoAfter" }}

     

       127
        
         <div class="flex flex-col gap-4 mt-4">

+30 -12

appview/pages/templates/repo/pulls/pull.html

···

       9
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       10
        
       {{ end }}

     

       11
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       12
        
       

     

       13
        
       {{ define "repoContent" }}

     

       14
        
         {{ template "repo/pulls/fragments/pullHeader" . }}

     
···

       39
        
           {{ with $item }}

     

       40
        
           <details {{ if eq $idx $lastIdx }}open{{ end }}>

     

       41
        
               <summary id="round-#{{ .RoundNumber }}" class="list-none cursor-pointer">

     

       42
       -
                 <div class="flex flex-wrap gap-2 items-center">

     

       43
        
                   <!-- round number -->

     

       44
        
                   <div class="rounded bg-white dark:bg-gray-800 drop-shadow-sm px-3 py-2 dark:text-white">

     

       45
        
                     <span class="flex items-center">{{ i "hash" "w-4 h-4" }}{{ .RoundNumber }}</span>

     

       46
        
                   </div>

     

       47
        
                   <!-- round summary -->

     

       48
       -
                   <div class="rounded drop-shadow-sm bg-white dark:bg-gray-800 p-2 text-gray-500 dark:text-gray-400">

     

       49
        
                     <span class="gap-1 flex items-center">

     

       50
        
                       {{ $owner := resolve $.Pull.OwnerDid }}

     

       51
        
                       {{ $re := "re" }}

     
···

       72
        
                     <span class="hidden md:inline">diff</span>

     

       73
        
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       74
        
                   </a>

     

       75
       -
                   {{ if not (eq .RoundNumber 0) }}

     

       76
       -
                   <a class="btn flex items-center gap-2 no-underline hover:no-underline p-2 group"

     

       77
       -
                      hx-boost="true"

     

       78
       -
                      href="/{{ $.RepoInfo.FullName }}/pulls/{{ $.Pull.PullId }}/round/{{.RoundNumber}}/interdiff">

     

       79
       -
                     {{ i "chevrons-left-right-ellipsis" "w-4 h-4 rotate-90" }}

     

       80
       -
                     <span class="hidden md:inline">interdiff</span>

     

       81
       -
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       82
       -
                   </a>

     

       83
       -
                   <span id="interdiff-error-{{.RoundNumber}}"></span>

     

       84
        
                   {{ end }}

     

       0
        
       
     

       85
        
                 </div>

     

       86
        
               </summary>

     

       87
        
       

     
···

       146
        
       

     

       147
        
               <div class="md:pl-[3.5rem] flex flex-col gap-2 mt-2 relative">

     

       148
        
                 {{ range $cidx, $c := .Comments }}

     

       149
       -
                   <div id="comment-{{$c.ID}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full md:max-w-3/5 md:w-fit">

     

       150
        
                     {{ if gt $cidx 0 }}

     

       151
        
                     <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div>

     

       152
        
                     {{ end }}

···

       9
        
           {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }}

     

       10
        
       {{ end }}

     

       11
        
       

     

       12
       +
       {{ define "repoContentLayout" }}

     

       13
       +
         <div class="grid grid-cols-1 md:grid-cols-10 gap-4 w-full">

     

       14
       +
           <div class="col-span-1 md:col-span-8">

     

       15
       +
             <section class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto dark:text-white">

     

       16
       +
               {{ block "repoContent" . }}{{ end }}

     

       17
       +
             </section>

     

       18
       +
             {{ block "repoAfter" . }}{{ end }}

     

       19
       +
           </div>

     

       20
       +
           <div class="col-span-1 md:col-span-2 flex flex-col gap-6">

     

       21
       +
             {{ template "repo/fragments/labelPanel"

     

       22
       +
               (dict "RepoInfo" $.RepoInfo

     

       23
       +
                     "Defs" $.LabelDefs

     

       24
       +
                     "Subject" $.Pull.PullAt

     

       25
       +
                     "State" $.Pull.Labels) }}

     

       26
       +
             {{ template "repo/fragments/participants" $.Pull.Participants }}

     

       27
       +
           </div>

     

       28
       +
         </div>

     

       29
       +
       {{ end }}

     

       30
        
       

     

       31
        
       {{ define "repoContent" }}

     

       32
        
         {{ template "repo/pulls/fragments/pullHeader" . }}

     
···

       57
        
           {{ with $item }}

     

       58
        
           <details {{ if eq $idx $lastIdx }}open{{ end }}>

     

       59
        
               <summary id="round-#{{ .RoundNumber }}" class="list-none cursor-pointer">

     

       60
       +
                 <div class="flex flex-wrap gap-2 items-stretch">

     

       61
        
                   <!-- round number -->

     

       62
        
                   <div class="rounded bg-white dark:bg-gray-800 drop-shadow-sm px-3 py-2 dark:text-white">

     

       63
        
                     <span class="flex items-center">{{ i "hash" "w-4 h-4" }}{{ .RoundNumber }}</span>

     

       64
        
                   </div>

     

       65
        
                   <!-- round summary -->

     

       66
       +
                   <div class="flex-1 rounded drop-shadow-sm bg-white dark:bg-gray-800 p-2 text-gray-500 dark:text-gray-400">

     

       67
        
                     <span class="gap-1 flex items-center">

     

       68
        
                       {{ $owner := resolve $.Pull.OwnerDid }}

     

       69
        
                       {{ $re := "re" }}

     
···

       90
        
                     <span class="hidden md:inline">diff</span>

     

       91
        
                     {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       92
        
                   </a>

     

       93
       +
                   {{ if ne $idx 0 }}

     

       94
       +
                     <a class="btn flex items-center gap-2 no-underline hover:no-underline p-2 group"

     

       95
       +
                        hx-boost="true"

     

       96
       +
                        href="/{{ $.RepoInfo.FullName }}/pulls/{{ $.Pull.PullId }}/round/{{.RoundNumber}}/interdiff">

     

       97
       +
                       {{ i "chevrons-left-right-ellipsis" "w-4 h-4 rotate-90" }}

     

       98
       +
                       <span class="hidden md:inline">interdiff</span>

     

       99
       +
                       {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}

     

       100
       +
                     </a>

     

       0
        
       
     

       101
        
                   {{ end }}

     

       102
       +
                   <span id="interdiff-error-{{.RoundNumber}}"></span>

     

       103
        
                 </div>

     

       104
        
               </summary>

     

       105
        
       

     
···

       164
        
       

     

       165
        
               <div class="md:pl-[3.5rem] flex flex-col gap-2 mt-2 relative">

     

       166
        
                 {{ range $cidx, $c := .Comments }}

     

       167
       +
                   <div id="comment-{{$c.ID}}" class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-2 px-4 relative w-full">

     

       168
        
                     {{ if gt $cidx 0 }}

     

       169
        
                     <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div>

     

       170
        
                     {{ end }}

appview/pages/templates/repo/pulls/pulls.html

···

       108
        
                             <span class="before:content-['·']"></span>

     

       109
        
                             {{ template "repo/pipelines/fragments/pipelineSymbol" $pipeline }}

     

       110
        
                           {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       111
        
                       </div>

     

       112
        
                     </div>

     

       113
        
                     {{ if .StackId }}

···

       108
        
                             <span class="before:content-['·']"></span>

     

       109
        
                             {{ template "repo/pipelines/fragments/pipelineSymbol" $pipeline }}

     

       110
        
                           {{ end }}

     

       111
       +
       

     

       112
       +
                           {{ $state := .Labels }}

     

       113
       +
                           {{ range $k, $d := $.LabelDefs }}

     

       114
       +
                             {{ range $v, $s := $state.GetValSet $d.AtUri.String }}

     

       115
       +
                               {{ template "labels/fragments/label" (dict "def" $d "val" $v "withPrefix" true) }}

     

       116
       +
                             {{ end }}

     

       117
       +
                           {{ end }}

     

       118
        
                       </div>

     

       119
        
                     </div>

     

       120
        
                     {{ if .StackId }}

+35

appview/pulls/pulls.go

···

       200
        
       		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.PullAt())

     

       201
        
       	}

     

       202
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       203
        
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       204
        
       		LoggedInUser:   user,

     

       205
        
       		RepoInfo:       repoInfo,

     
···

       213
        
       		OrderedReactionKinds: models.OrderedReactionKinds,

     

       214
        
       		Reactions:            reactionCountMap,

     

       215
        
       		UserReacted:          userReactions,

     

       0
        
       
     

       0
        
       
     

       216
        
       	})

     

       217
        
       }

     

       218
        
       

     
···

       557
        
       		m[p.Sha] = p

     

       558
        
       	}

     

       559
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       560
        
       	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       561
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       562
        
       		RepoInfo:     f.RepoInfo(user),

     

       563
        
       		Pulls:        pulls,

     

       0
        
       
     

       564
        
       		FilteringBy:  state,

     

       565
        
       		Stacks:       stacks,

     

       566
        
       		Pipelines:    m,

···

       200
        
       		userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.PullAt())

     

       201
        
       	}

     

       202
        
       

     

       203
       +
       	labelDefs, err := db.GetLabelDefinitions(

     

       204
       +
       		s.db,

     

       205
       +
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       206
       +
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       207
       +
       	)

     

       208
       +
       	if err != nil {

     

       209
       +
       		log.Println("failed to fetch labels", err)

     

       210
       +
       		s.pages.Error503(w)

     

       211
       +
       		return

     

       212
       +
       	}

     

       213
       +
       

     

       214
       +
       	defs := make(map[string]*models.LabelDefinition)

     

       215
       +
       	for _, l := range labelDefs {

     

       216
       +
       		defs[l.AtUri().String()] = &l

     

       217
       +
       	}

     

       218
       +
       

     

       219
        
       	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{

     

       220
        
       		LoggedInUser:   user,

     

       221
        
       		RepoInfo:       repoInfo,

     
···

       229
        
       		OrderedReactionKinds: models.OrderedReactionKinds,

     

       230
        
       		Reactions:            reactionCountMap,

     

       231
        
       		UserReacted:          userReactions,

     

       232
       +
       

     

       233
       +
       		LabelDefs: defs,

     

       234
        
       	})

     

       235
        
       }

     

       236
        
       

     
···

       575
        
       		m[p.Sha] = p

     

       576
        
       	}

     

       577
        
       

     

       578
       +
       	labelDefs, err := db.GetLabelDefinitions(

     

       579
       +
       		s.db,

     

       580
       +
       		db.FilterIn("at_uri", f.Repo.Labels),

     

       581
       +
       		db.FilterContains("scope", tangled.RepoPullNSID),

     

       582
       +
       	)

     

       583
       +
       	if err != nil {

     

       584
       +
       		log.Println("failed to fetch labels", err)

     

       585
       +
       		s.pages.Error503(w)

     

       586
       +
       		return

     

       587
       +
       	}

     

       588
       +
       

     

       589
       +
       	defs := make(map[string]*models.LabelDefinition)

     

       590
       +
       	for _, l := range labelDefs {

     

       591
       +
       		defs[l.AtUri().String()] = &l

     

       592
       +
       	}

     

       593
       +
       

     

       594
        
       	s.pages.RepoPulls(w, pages.RepoPullsParams{

     

       595
        
       		LoggedInUser: s.oauth.GetUser(r),

     

       596
        
       		RepoInfo:     f.RepoInfo(user),

     

       597
        
       		Pulls:        pulls,

     

       598
       +
       		LabelDefs:    defs,

     

       599
        
       		FilteringBy:  state,

     

       600
        
       		Stacks:       stacks,

     

       601
        
       		Pipelines:    m,

+8 -48

appview/notify/db/db.go

···

       30
        
       

     

       31
        
       func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       32
        
       	var err error

     

       33
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(star.RepoAt)))

     

       34
        
       	if err != nil {

     

       35
        
       		log.Printf("NewStar: failed to get repos: %v", err)

     

       36
        
       		return

     

       37
        
       	}

     

       38
       -
       	if len(repos) == 0 {

     

       39
       -
       		log.Printf("NewStar: no repo found for %s", star.RepoAt)

     

       40
       -
       		return

     

       41
       -
       	}

     

       42
       -
       	repo := repos[0]

     

       43
        
       

     

       44
        
       	// don't notify yourself

     

       45
        
       	if repo.Did == star.StarredByDid {

     
···

       76
        
       }

     

       77
        
       

     

       78
        
       func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue) {

     

       79
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       80
        
       	if err != nil {

     

       81
        
       		log.Printf("NewIssue: failed to get repos: %v", err)

     

       82
        
       		return

     

       83
        
       	}

     

       84
       -
       	if len(repos) == 0 {

     

       85
       -
       		log.Printf("NewIssue: no repo found for %s", issue.RepoAt)

     

       86
       -
       		return

     

       87
       -
       	}

     

       88
       -
       	repo := repos[0]

     

       89
        
       

     

       90
        
       	if repo.Did == issue.Did {

     

       91
        
       		return

     
···

       129
        
       	}

     

       130
        
       	issue := issues[0]

     

       131
        
       

     

       132
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       133
        
       	if err != nil {

     

       134
        
       		log.Printf("NewIssueComment: failed to get repos: %v", err)

     

       135
        
       		return

     

       136
        
       	}

     

       137
       -
       	if len(repos) == 0 {

     

       138
       -
       		log.Printf("NewIssueComment: no repo found for %s", issue.RepoAt)

     

       139
       -
       		return

     

       140
       -
       	}

     

       141
       -
       	repo := repos[0]

     

       142
        
       

     

       143
        
       	recipients := make(map[string]bool)

     

       144
        
       

     
···

       211
        
       }

     

       212
        
       

     

       213
        
       func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {

     

       214
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       215
        
       	if err != nil {

     

       216
        
       		log.Printf("NewPull: failed to get repos: %v", err)

     

       217
        
       		return

     

       218
        
       	}

     

       219
       -
       	if len(repos) == 0 {

     

       220
       -
       		log.Printf("NewPull: no repo found for %s", pull.RepoAt)

     

       221
       -
       		return

     

       222
       -
       	}

     

       223
       -
       	repo := repos[0]

     

       224
        
       

     

       225
        
       	if repo.Did == pull.OwnerDid {

     

       226
        
       		return

     
···

       266
        
       	}

     

       267
        
       	pull := pulls[0]

     

       268
        
       

     

       269
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", comment.RepoAt))

     

       270
        
       	if err != nil {

     

       271
        
       		log.Printf("NewPullComment: failed to get repos: %v", err)

     

       272
        
       		return

     

       273
        
       	}

     

       274
       -
       	if len(repos) == 0 {

     

       275
       -
       		log.Printf("NewPullComment: no repo found for %s", comment.RepoAt)

     

       276
       -
       		return

     

       277
       -
       	}

     

       278
       -
       	repo := repos[0]

     

       279
        
       

     

       280
        
       	recipients := make(map[string]bool)

     

       281
        
       

     
···

       335
        
       

     

       336
        
       func (n *databaseNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       337
        
       	// Get repo details

     

       338
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       339
        
       	if err != nil {

     

       340
        
       		log.Printf("NewIssueClosed: failed to get repos: %v", err)

     

       341
        
       		return

     

       342
        
       	}

     

       343
       -
       	if len(repos) == 0 {

     

       344
       -
       		log.Printf("NewIssueClosed: no repo found for %s", issue.RepoAt)

     

       345
       -
       		return

     

       346
       -
       	}

     

       347
       -
       	repo := repos[0]

     

       348
        
       

     

       349
        
       	// Don't notify yourself

     

       350
        
       	if repo.Did == issue.Did {

     
···

       380
        
       

     

       381
        
       func (n *databaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       382
        
       	// Get repo details

     

       383
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       384
        
       	if err != nil {

     

       385
        
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       386
        
       		return

     

       387
        
       	}

     

       388
       -
       	if len(repos) == 0 {

     

       389
       -
       		log.Printf("NewPullMerged: no repo found for %s", pull.RepoAt)

     

       390
       -
       		return

     

       391
       -
       	}

     

       392
       -
       	repo := repos[0]

     

       393
        
       

     

       394
        
       	// Don't notify yourself

     

       395
        
       	if repo.Did == pull.OwnerDid {

     
···

       425
        
       

     

       426
        
       func (n *databaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       427
        
       	// Get repo details

     

       428
       -
       	repos, err := db.GetRepos(n.db, 1, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       429
        
       	if err != nil {

     

       430
        
       		log.Printf("NewPullClosed: failed to get repos: %v", err)

     

       431
        
       		return

     

       432
        
       	}

     

       433
       -
       	if len(repos) == 0 {

     

       434
       -
       		log.Printf("NewPullClosed: no repo found for %s", pull.RepoAt)

     

       435
       -
       		return

     

       436
       -
       	}

     

       437
       -
       	repo := repos[0]

     

       438
        
       

     

       439
        
       	// Don't notify yourself

     

       440
        
       	if repo.Did == pull.OwnerDid {

···

       30
        
       

     

       31
        
       func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {

     

       32
        
       	var err error

     

       33
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(star.RepoAt)))

     

       34
        
       	if err != nil {

     

       35
        
       		log.Printf("NewStar: failed to get repos: %v", err)

     

       36
        
       		return

     

       37
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       38
        
       

     

       39
        
       	// don't notify yourself

     

       40
        
       	if repo.Did == star.StarredByDid {

     
···

       71
        
       }

     

       72
        
       

     

       73
        
       func (n *databaseNotifier) NewIssue(ctx context.Context, issue *models.Issue) {

     

       74
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       75
        
       	if err != nil {

     

       76
        
       		log.Printf("NewIssue: failed to get repos: %v", err)

     

       77
        
       		return

     

       78
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       79
        
       

     

       80
        
       	if repo.Did == issue.Did {

     

       81
        
       		return

     
···

       119
        
       	}

     

       120
        
       	issue := issues[0]

     

       121
        
       

     

       122
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       123
        
       	if err != nil {

     

       124
        
       		log.Printf("NewIssueComment: failed to get repos: %v", err)

     

       125
        
       		return

     

       126
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       127
        
       

     

       128
        
       	recipients := make(map[string]bool)

     

       129
        
       

     
···

       196
        
       }

     

       197
        
       

     

       198
        
       func (n *databaseNotifier) NewPull(ctx context.Context, pull *models.Pull) {

     

       199
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       200
        
       	if err != nil {

     

       201
        
       		log.Printf("NewPull: failed to get repos: %v", err)

     

       202
        
       		return

     

       203
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       204
        
       

     

       205
        
       	if repo.Did == pull.OwnerDid {

     

       206
        
       		return

     
···

       246
        
       	}

     

       247
        
       	pull := pulls[0]

     

       248
        
       

     

       249
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", comment.RepoAt))

     

       250
        
       	if err != nil {

     

       251
        
       		log.Printf("NewPullComment: failed to get repos: %v", err)

     

       252
        
       		return

     

       253
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       254
        
       

     

       255
        
       	recipients := make(map[string]bool)

     

       256
        
       

     
···

       310
        
       

     

       311
        
       func (n *databaseNotifier) NewIssueClosed(ctx context.Context, issue *models.Issue) {

     

       312
        
       	// Get repo details

     

       313
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(issue.RepoAt)))

     

       314
        
       	if err != nil {

     

       315
        
       		log.Printf("NewIssueClosed: failed to get repos: %v", err)

     

       316
        
       		return

     

       317
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       318
        
       

     

       319
        
       	// Don't notify yourself

     

       320
        
       	if repo.Did == issue.Did {

     
···

       350
        
       

     

       351
        
       func (n *databaseNotifier) NewPullMerged(ctx context.Context, pull *models.Pull) {

     

       352
        
       	// Get repo details

     

       353
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       354
        
       	if err != nil {

     

       355
        
       		log.Printf("NewPullMerged: failed to get repos: %v", err)

     

       356
        
       		return

     

       357
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       358
        
       

     

       359
        
       	// Don't notify yourself

     

       360
        
       	if repo.Did == pull.OwnerDid {

     
···

       390
        
       

     

       391
        
       func (n *databaseNotifier) NewPullClosed(ctx context.Context, pull *models.Pull) {

     

       392
        
       	// Get repo details

     

       393
       +
       	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(pull.RepoAt)))

     

       394
        
       	if err != nil {

     

       395
        
       		log.Printf("NewPullClosed: failed to get repos: %v", err)

     

       396
        
       		return

     

       397
        
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       398
        
       

     

       399
        
       	// Don't notify yourself

     

       400
        
       	if repo.Did == pull.OwnerDid {

+18 -13

appview/db/notifications.go

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"database/sql"

     

       0
        
       
     

       6
        
       	"fmt"

     

       0
        
       
     

       7
        
       	"time"

     

       8
        
       

     

       9
        
       	"tangled.org/core/appview/models"

     
···

       248
        
       	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       249
        
       }

     

       250
        
       

     

       251
       -
       func (d *DB) GetUnreadNotificationCount(ctx context.Context, userDID string) (int, error) {

     

       252
       -
       	recipientFilter := FilterEq("recipient_did", userDID)

     

       253
       -
       	readFilter := FilterEq("read", 0)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       254
        
       

     

       255
       -
       	query := fmt.Sprintf(`

     

       256
       -
       		SELECT COUNT(*)

     

       257
       -
       		FROM notifications

     

       258
       -
       		WHERE %s AND %s

     

       259
       -
       	`, recipientFilter.Condition(), readFilter.Condition())

     

       260
        
       

     

       261
       -
       	args := append(recipientFilter.Arg(), readFilter.Arg()...)

     

       0
        
       
     

       0
        
       
     

       262
        
       

     

       263
       -
       	var count int

     

       264
       -
       	err := d.DB.QueryRowContext(ctx, query, args...).Scan(&count)

     

       265
       -
       	if err != nil {

     

       266
       -
       		return 0, fmt.Errorf("failed to get unread count: %w", err)

     

       267
        
       	}

     

       268
        
       

     

       269
        
       	return count, nil

···

       3
        
       import (

     

       4
        
       	"context"

     

       5
        
       	"database/sql"

     

       6
       +
       	"errors"

     

       7
        
       	"fmt"

     

       8
       +
       	"strings"

     

       9
        
       	"time"

     

       10
        
       

     

       11
        
       	"tangled.org/core/appview/models"

     
···

       250
        
       	return GetNotificationsPaginated(e, pagination.FirstPage(), filters...)

     

       251
        
       }

     

       252
        
       

     

       253
       +
       func CountNotifications(e Execer, filters ...filter) (int64, error) {

     

       254
       +
       	var conditions []string

     

       255
       +
       	var args []any

     

       256
       +
       	for _, filter := range filters {

     

       257
       +
       		conditions = append(conditions, filter.Condition())

     

       258
       +
       		args = append(args, filter.Arg()...)

     

       259
       +
       	}

     

       260
        
       

     

       261
       +
       	whereClause := ""

     

       262
       +
       	if conditions != nil {

     

       263
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       264
       +
       	}

     

       0
        
       
     

       265
        
       

     

       266
       +
       	query := fmt.Sprintf(`select count(1) from notifications %s`, whereClause)

     

       267
       +
       	var count int64

     

       268
       +
       	err := e.QueryRow(query, args...).Scan(&count)

     

       269
        
       

     

       270
       +
       	if !errors.Is(err, sql.ErrNoRows) && err != nil {

     

       271
       +
       		return 0, err

     

       0
        
       
     

       0
        
       
     

       272
        
       	}

     

       273
        
       

     

       274
        
       	return count, nil

+29 -36

appview/notifications/notifications.go

···

       1
        
       package notifications

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"log"

     

       5
        
       	"net/http"

     

       6
        
       	"strconv"

     
···

       32
        
       

     

       33
        
       	r.Use(middleware.AuthMiddleware(n.oauth))

     

       34
        
       

     

       35
       -
       	r.Get("/", n.notificationsPage)

     

       36
        
       

     

       37
        
       	r.Get("/count", n.getUnreadCount)

     

       38
        
       	r.Post("/{id}/read", n.markRead)

     
···

       45
        
       func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {

     

       46
        
       	userDid := n.oauth.GetDid(r)

     

       47
        
       

     

       48
       -
       	limitStr := r.URL.Query().Get("limit")

     

       49
       -
       	offsetStr := r.URL.Query().Get("offset")

     

       50
       -
       

     

       51
       -
       	limit := 20 // default

     

       52
       -
       	if limitStr != "" {

     

       53
       -
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {

     

       54
       -
       			limit = l

     

       55
       -
       		}

     

       56
        
       	}

     

       57
        
       

     

       58
       -
       	offset := 0 // default

     

       59
       -
       	if offsetStr != "" {

     

       60
       -
       		if o, err := strconv.Atoi(offsetStr); err == nil && o >= 0 {

     

       61
       -
       			offset = o

     

       62
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       63
        
       	}

     

       64
        
       

     

       65
       -
       	page := pagination.Page{Limit: limit + 1, Offset: offset}

     

       66
       -
       	notifications, err := db.GetNotificationsWithEntities(n.db, page, db.FilterEq("recipient_did", userDid))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       67
        
       	if err != nil {

     

       68
        
       		log.Println("failed to get notifications:", err)

     

       69
        
       		n.pages.Error500(w)

     

       70
        
       		return

     

       71
        
       	}

     

       72
        
       

     

       73
       -
       	hasMore := len(notifications) > limit

     

       74
       -
       	if hasMore {

     

       75
       -
       		notifications = notifications[:limit]

     

       76
       -
       	}

     

       77
       -
       

     

       78
        
       	err = n.db.MarkAllNotificationsRead(r.Context(), userDid)

     

       79
        
       	if err != nil {

     

       80
        
       		log.Println("failed to mark notifications as read:", err)

     
···

       88
        
       		return

     

       89
        
       	}

     

       90
        
       

     

       91
       -
       	params := pages.NotificationsParams{

     

       92
        
       		LoggedInUser:  user,

     

       93
        
       		Notifications: notifications,

     

       94
        
       		UnreadCount:   unreadCount,

     

       95
       -
       		HasMore:       hasMore,

     

       96
       -
       		NextOffset:    offset + limit,

     

       97
       -
       		Limit:         limit,

     

       98
       -
       	}

     

       99
       -
       

     

       100
       -
       	err = n.pages.Notifications(w, params)

     

       101
       -
       	if err != nil {

     

       102
       -
       		log.Println("failed to load notifs:", err)

     

       103
       -
       		n.pages.Error500(w)

     

       104
       -
       		return

     

       105
       -
       	}

     

       106
        
       }

     

       107
        
       

     

       108
        
       func (n *Notifications) getUnreadCount(w http.ResponseWriter, r *http.Request) {

     

       109
       -
       	userDid := n.oauth.GetDid(r)

     

       110
       -
       

     

       111
       -
       	count, err := n.db.GetUnreadNotificationCount(r.Context(), userDid)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       112
        
       	if err != nil {

     

       113
        
       		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)

     

       114
        
       		return

···

       1
        
       package notifications

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"fmt"

     

       5
        
       	"log"

     

       6
        
       	"net/http"

     

       7
        
       	"strconv"

     
···

       33
        
       

     

       34
        
       	r.Use(middleware.AuthMiddleware(n.oauth))

     

       35
        
       

     

       36
       +
       	r.With(middleware.Paginate).Get("/", n.notificationsPage)

     

       37
        
       

     

       38
        
       	r.Get("/count", n.getUnreadCount)

     

       39
        
       	r.Post("/{id}/read", n.markRead)

     
···

       46
        
       func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {

     

       47
        
       	userDid := n.oauth.GetDid(r)

     

       48
        
       

     

       49
       +
       	page, ok := r.Context().Value("page").(pagination.Page)

     

       50
       +
       	if !ok {

     

       51
       +
       		log.Println("failed to get page")

     

       52
       +
       		page = pagination.FirstPage()

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
       	}

     

       54
        
       

     

       55
       +
       	total, err := db.CountNotifications(

     

       56
       +
       		n.db,

     

       57
       +
       		db.FilterEq("recipient_did", userDid),

     

       58
       +
       	)

     

       59
       +
       	if err != nil {

     

       60
       +
       		log.Println("failed to get total notifications:", err)

     

       61
       +
       		n.pages.Error500(w)

     

       62
       +
       		return

     

       63
        
       	}

     

       64
        
       

     

       65
       +
       	notifications, err := db.GetNotificationsWithEntities(

     

       66
       +
       		n.db,

     

       67
       +
       		page,

     

       68
       +
       		db.FilterEq("recipient_did", userDid),

     

       69
       +
       	)

     

       70
        
       	if err != nil {

     

       71
        
       		log.Println("failed to get notifications:", err)

     

       72
        
       		n.pages.Error500(w)

     

       73
        
       		return

     

       74
        
       	}

     

       75
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       76
        
       	err = n.db.MarkAllNotificationsRead(r.Context(), userDid)

     

       77
        
       	if err != nil {

     

       78
        
       		log.Println("failed to mark notifications as read:", err)

     
···

       86
        
       		return

     

       87
        
       	}

     

       88
        
       

     

       89
       +
       	fmt.Println(n.pages.Notifications(w, pages.NotificationsParams{

     

       90
        
       		LoggedInUser:  user,

     

       91
        
       		Notifications: notifications,

     

       92
        
       		UnreadCount:   unreadCount,

     

       93
       +
       		Page:          page,

     

       94
       +
       		Total:         total,

     

       95
       +
       	}))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       96
        
       }

     

       97
        
       

     

       98
        
       func (n *Notifications) getUnreadCount(w http.ResponseWriter, r *http.Request) {

     

       99
       +
       	user := n.oauth.GetUser(r)

     

       100
       +
       	count, err := db.CountNotifications(

     

       101
       +
       		n.db,

     

       102
       +
       		db.FilterEq("recipient_did", user.Did),

     

       103
       +
       		db.FilterEq("read", 0),

     

       104
       +
       	)

     

       105
        
       	if err != nil {

     

       106
        
       		http.Error(w, "Failed to get unread count", http.StatusInternalServerError)

     

       107
        
       		return

+48 -15

appview/pages/templates/notifications/list.html

···

       11
        
           </div>

     

       12
        
         </div>

     

       13
        
       

     

       14
       -
           {{if .Notifications}}

     

       15
       -
             <div class="flex flex-col gap-2" id="notifications-list">

     

       16
       -
               {{range .Notifications}}

     

       17
       -
                 {{template "notifications/fragments/item" .}}

     

       18
       -
               {{end}}

     

       19
       -
             </div>

     

       20
        
       

     

       21
       -
           {{else}}

     

       22
       -
             <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       23
       -
               <div class="text-center py-12">

     

       24
       -
                 <div class="w-16 h-16 mx-auto mb-4 text-gray-300 dark:text-gray-600">

     

       25
       -
                   {{ i "bell-off" "w-16 h-16" }}

     

       26
       -
                 </div>

     

       27
       -
                 <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">No notifications</h3>

     

       28
       -
                 <p class="text-gray-600 dark:text-gray-400">When you receive notifications, they'll appear here.</p>

     

       29
        
               </div>

     

       0
        
       
     

       0
        
       
     

       30
        
             </div>

     

       31
       -
           {{end}}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       {{ end }}

···

       11
        
           </div>

     

       12
        
         </div>

     

       13
        
       

     

       14
       +
         {{if .Notifications}}

     

       15
       +
           <div class="flex flex-col gap-2" id="notifications-list">

     

       16
       +
             {{range .Notifications}}

     

       17
       +
               {{template "notifications/fragments/item" .}}

     

       18
       +
             {{end}}

     

       19
       +
           </div>

     

       20
        
       

     

       21
       +
         {{else}}

     

       22
       +
           <div class="bg-white dark:bg-gray-800 p-6 rounded relative w-full mx-auto drop-shadow-sm dark:text-white">

     

       23
       +
             <div class="text-center py-12">

     

       24
       +
               <div class="w-16 h-16 mx-auto mb-4 text-gray-300 dark:text-gray-600">

     

       25
       +
                 {{ i "bell-off" "w-16 h-16" }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
               </div>

     

       27
       +
               <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">No notifications</h3>

     

       28
       +
               <p class="text-gray-600 dark:text-gray-400">When you receive notifications, they'll appear here.</p>

     

       29
        
             </div>

     

       30
       +
           </div>

     

       31
       +
         {{end}}

     

       32
       +
       

     

       33
       +
         {{ template "pagination" . }}

     

       34
       +
       {{ end }}

     

       35
       +
       

     

       36
       +
       {{ define "pagination" }}

     

       37
       +
         <div class="flex justify-end mt-4 gap-2">

     

       38
       +
             {{ if gt .Page.Offset 0 }}

     

       39
       +
                {{ $prev := .Page.Previous }}

     

       40
       +
                 <a

     

       41
       +
                     class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       42
       +
                     hx-boost="true"

     

       43
       +
                     href = "/notifications?offset={{ $prev.Offset }}&limit={{ $prev.Limit }}"

     

       44
       +
                 >

     

       45
       +
                     {{ i "chevron-left" "w-4 h-4" }}

     

       46
       +
                     previous

     

       47
       +
                 </a>

     

       48
       +
             {{ else }}

     

       49
       +
                 <div></div>

     

       50
       +
             {{ end }}

     

       51
       +
       

     

       52
       +
             {{ $next := .Page.Next }}

     

       53
       +
             {{ if lt $next.Offset .Total }}

     

       54
       +
                {{ $next := .Page.Next }}

     

       55
       +
                 <a

     

       56
       +
                     class="btn flex items-center gap-2 no-underline hover:no-underline dark:text-white dark:hover:bg-gray-700"

     

       57
       +
                     hx-boost="true"

     

       58
       +
                     href = "/notifications?offset={{ $next.Offset }}&limit={{ $next.Limit }}"

     

       59
       +
                 >

     

       60
       +
                     next

     

       61
       +
                     {{ i "chevron-right" "w-4 h-4" }}

     

       62
       +
                 </a>

     

       63
       +
             {{ end }}

     

       64
       +
         </div>

     

       65
        
       {{ end }}

+1 -1

appview/pagination/page.go

···

       8
        
       func FirstPage() Page {

     

       9
        
       	return Page{

     

       10
        
       		Offset: 0,

     

       11
       -
       		Limit:  10,

     

       12
        
       	}

     

       13
        
       }

     

       14

···

       8
        
       func FirstPage() Page {

     

       9
        
       	return Page{

     

       10
        
       		Offset: 0,

     

       11
       +
       		Limit:  30,

     

       12
        
       	}

     

       13
        
       }

     

       14

+27 -208

appview/pages/templates/notifications/fragments/item.html

···

       1
        
       {{define "notifications/fragments/item"}}

     

       2
       -
         <div 

     

       3
       -
           class="

     

       4
       -
             w-full mx-auto rounded drop-shadow-sm dark:text-white bg-white dark:bg-gray-800 px-2 md:px-6 py-4 transition-colors 

     

       5
       -
             {{if not .Read}}bg-blue-50 dark:bg-blue-900/20 border border-blue-500 dark:border-sky-800{{end}}

     

       6
       -
             flex gap-2 items-center

     

       7
       -
             "

     

       8
       -
           >

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
       

     

       10
       -
           {{ template "notificationIcon" . }}

     

       11
       -
           <div class="flex-1 w-full flex flex-col gap-1">

     

       12
       -
             <span>{{ template "notificationHeader" . }}</span>

     

       13
       -
             <span class="text-sm text-gray-500 dark:text-gray-400">{{ template "notificationSummary" . }}</span>

     

       14
        
           </div>

     

       15
       -
       

     

       16
       -
         </div>

     

       17
        
       {{end}}

     

       18
        
       

     

       19
        
       {{ define "notificationIcon" }}

     
···

       64
        
         {{ end }}

     

       65
        
       {{ end }}

     

       66
        
       

     

       67
       -
       {{define "issueNotification"}}

     

       68
       -
       {{$url := printf "/%s/%s/issues/%d" (resolve .Repo.Did) .Repo.Name .Issue.IssueId}}

     

       69
       -
       <a

     

       70
       -
         href="{{$url}}"

     

       71
       -
         class="block no-underline hover:no-underline text-inherit -m-3 p-3"

     

       72
       -
       >

     

       73
       -
         <div class="flex items-center justify-between">

     

       74
       -
           <div class="min-w-0 flex-1">

     

       75
       -
             <!-- First line: icon + actor action -->

     

       76
       -
             <div class="flex items-center gap-2 text-gray-900 dark:text-white">

     

       77
       -
               {{if eq .Type "issue_created"}}

     

       78
       -
                 <span class="text-green-600 dark:text-green-500">

     

       79
       -
                   {{ i "circle-dot" "w-4 h-4" }}

     

       80
       -
                 </span>

     

       81
       -
               {{else if eq .Type "issue_commented"}}

     

       82
       -
                 <span class="text-gray-500 dark:text-gray-400">

     

       83
       -
                   {{ i "message-circle" "w-4 h-4" }}

     

       84
       -
                 </span>

     

       85
       -
               {{else if eq .Type "issue_closed"}}

     

       86
       -
                 <span class="text-gray-500 dark:text-gray-400">

     

       87
       -
                   {{ i "ban" "w-4 h-4" }}

     

       88
       -
                 </span>

     

       89
       -
               {{end}}

     

       90
       -
               {{template "user/fragments/picHandle" .ActorDid}}

     

       91
       -
               {{if eq .Type "issue_created"}}

     

       92
       -
                 <span class="text-gray-500 dark:text-gray-400">opened issue</span>

     

       93
       -
               {{else if eq .Type "issue_commented"}}

     

       94
       -
                 <span class="text-gray-500 dark:text-gray-400">commented on issue</span>

     

       95
       -
               {{else if eq .Type "issue_closed"}}

     

       96
       -
                 <span class="text-gray-500 dark:text-gray-400">closed issue</span>

     

       97
       -
               {{end}}

     

       98
       -
               {{if not .Read}}

     

       99
       -
                 <div class="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0 ml-1"></div>

     

       100
       -
               {{end}}

     

       101
       -
             </div>

     

       102
       -
       

     

       103
       -
             <div class="text-sm text-gray-600 dark:text-gray-400 mt-0.5 ml-6 flex items-center gap-1">

     

       104
       -
               <span class="text-gray-500 dark:text-gray-400">#{{.Issue.IssueId}}</span>

     

       105
       -
               <span class="text-gray-900 dark:text-white truncate">{{.Issue.Title}}</span>

     

       106
       -
               <span>on</span>

     

       107
       -
               <span class="font-medium text-gray-900 dark:text-white">{{resolve .Repo.Did}}/{{.Repo.Name}}</span>

     

       108
       -
             </div>

     

       109
       -
           </div>

     

       110
       -
       

     

       111
       -
           <div class="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0 ml-2">

     

       112
       -
             {{ template "repo/fragments/time" .Created }}

     

       113
       -
           </div>

     

       114
       -
         </div>

     

       115
       -
       </a>

     

       116
       -
       {{end}}

     

       117
       -
       

     

       118
       -
       {{define "pullNotification"}}

     

       119
       -
       {{$url := printf "/%s/%s/pulls/%d" (resolve .Repo.Did) .Repo.Name .Pull.PullId}}

     

       120
       -
       <a

     

       121
       -
         href="{{$url}}"

     

       122
       -
         class="block no-underline hover:no-underline text-inherit -m-3 p-3"

     

       123
       -
       >

     

       124
       -
         <div class="flex items-center justify-between">

     

       125
       -
           <div class="min-w-0 flex-1">

     

       126
       -
             <div class="flex items-center gap-2 text-gray-900 dark:text-white">

     

       127
       -
               {{if eq .Type "pull_created"}}

     

       128
       -
                 <span class="text-green-600 dark:text-green-500">

     

       129
       -
                   {{ i "git-pull-request-create" "w-4 h-4" }}

     

       130
       -
                 </span>

     

       131
       -
               {{else if eq .Type "pull_commented"}}

     

       132
       -
                 <span class="text-gray-500 dark:text-gray-400">

     

       133
       -
                   {{ i "message-circle" "w-4 h-4" }}

     

       134
       -
                 </span>

     

       135
       -
               {{else if eq .Type "pull_merged"}}

     

       136
       -
                 <span class="text-purple-600 dark:text-purple-500">

     

       137
       -
                   {{ i "git-merge" "w-4 h-4" }}

     

       138
       -
                 </span>

     

       139
       -
               {{else if eq .Type "pull_closed"}}

     

       140
       -
                 <span class="text-red-600 dark:text-red-500">

     

       141
       -
                   {{ i "git-pull-request-closed" "w-4 h-4" }}

     

       142
       -
                 </span>

     

       143
       -
               {{end}}

     

       144
       -
               {{template "user/fragments/picHandle" (resolve .ActorDid)}}

     

       145
       -
               {{if eq .Type "pull_created"}}

     

       146
       -
                 <span class="text-gray-500 dark:text-gray-400">opened pull request</span>

     

       147
       -
               {{else if eq .Type "pull_commented"}}

     

       148
       -
                 <span class="text-gray-500 dark:text-gray-400">commented on pull request</span>

     

       149
       -
               {{else if eq .Type "pull_merged"}}

     

       150
       -
                 <span class="text-gray-500 dark:text-gray-400">merged pull request</span>

     

       151
       -
               {{else if eq .Type "pull_closed"}}

     

       152
       -
                 <span class="text-gray-500 dark:text-gray-400">closed pull request</span>

     

       153
       -
               {{end}}

     

       154
       -
               {{if not .Read}}

     

       155
       -
                 <div class="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0 ml-1"></div>

     

       156
       -
               {{end}}

     

       157
       -
             </div>

     

       158
       -
       

     

       159
       -
             <div class="text-sm text-gray-600 dark:text-gray-400 mt-0.5 ml-6 flex items-center gap-1">

     

       160
       -
               <span class="text-gray-500 dark:text-gray-400">#{{.Pull.PullId}}</span>

     

       161
       -
               <span class="text-gray-900 dark:text-white truncate">{{.Pull.Title}}</span>

     

       162
       -
               <span>on</span>

     

       163
       -
               <span class="font-medium text-gray-900 dark:text-white">{{resolve .Repo.Did}}/{{.Repo.Name}}</span>

     

       164
       -
             </div>

     

       165
       -
           </div>

     

       166
       -
       

     

       167
       -
           <div class="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0 ml-2">

     

       168
       -
             {{ template "repo/fragments/time" .Created }}

     

       169
       -
           </div>

     

       170
       -
         </div>

     

       171
       -
       </a>

     

       172
       -
       {{end}}

     

       173
       -
       

     

       174
       -
       {{define "repoNotification"}}

     

       175
       -
       {{$url := printf "/%s/%s" (resolve .Repo.Did) .Repo.Name}}

     

       176
       -
       <a

     

       177
       -
         href="{{$url}}"

     

       178
       -
         class="block no-underline hover:no-underline text-inherit -m-3 p-3"

     

       179
       -
       >

     

       180
       -
         <div class="flex items-center justify-between">

     

       181
       -
           <div class="flex items-center gap-2 min-w-0 flex-1">

     

       182
       -
             <span class="text-yellow-500 dark:text-yellow-400">

     

       183
       -
               {{ i "star" "w-4 h-4" }}

     

       184
       -
             </span>

     

       185
       -
       

     

       186
       -
             <div class="min-w-0 flex-1">

     

       187
       -
               <!-- Single line for stars: actor action subject -->

     

       188
       -
               <div class="flex items-center gap-1 text-gray-900 dark:text-white">

     

       189
       -
                 {{template "user/fragments/picHandle" (resolve .ActorDid)}}

     

       190
       -
                 <span class="text-gray-500 dark:text-gray-400">starred</span>

     

       191
       -
                 <span class="font-medium">{{resolve .Repo.Did}}/{{.Repo.Name}}</span>

     

       192
       -
                 {{if not .Read}}

     

       193
       -
                   <div class="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0 ml-1"></div>

     

       194
       -
                 {{end}}

     

       195
       -
               </div>

     

       196
       -
             </div>

     

       197
       -
           </div>

     

       198
       -
       

     

       199
       -
           <div class="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0 ml-2">

     

       200
       -
             {{ template "repo/fragments/time" .Created }}

     

       201
       -
           </div>

     

       202
       -
         </div>

     

       203
       -
       </a>

     

       204
       -
       {{end}}

     

       205
       -
       

     

       206
       -
       {{define "followNotification"}}

     

       207
       -
       {{$url := printf "/%s" (resolve .ActorDid)}}

     

       208
       -
       <a

     

       209
       -
         href="{{$url}}"

     

       210
       -
         class="block no-underline hover:no-underline text-inherit -m-3 p-3"

     

       211
       -
       >

     

       212
       -
         <div class="flex items-center justify-between">

     

       213
       -
           <div class="flex items-center gap-2 min-w-0 flex-1">

     

       214
       -
             <span class="text-blue-600 dark:text-blue-400">

     

       215
       -
               {{ i "user-plus" "w-4 h-4" }}

     

       216
       -
             </span>

     

       217
       -
       

     

       218
       -
             <div class="min-w-0 flex-1">

     

       219
       -
               <div class="flex items-center gap-1 text-gray-900 dark:text-white">

     

       220
       -
                 {{template "user/fragments/picHandle" (resolve .ActorDid)}}

     

       221
       -
                 <span class="text-gray-500 dark:text-gray-400">followed you</span>

     

       222
       -
                 {{if not .Read}}

     

       223
       -
                   <div class="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0 ml-1"></div>

     

       224
       -
                 {{end}}

     

       225
       -
               </div>

     

       226
       -
             </div>

     

       227
       -
           </div>

     

       228
       -
       

     

       229
       -
           <div class="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0 ml-2">

     

       230
       -
             {{ template "repo/fragments/time" .Created }}

     

       231
       -
           </div>

     

       232
       -
         </div>

     

       233
       -
       </a>

     

       234
       -
       {{end}}

     

       235
       -
       

     

       236
       -
       {{define "genericNotification"}}

     

       237
       -
       <a

     

       238
       -
         href="#"

     

       239
       -
         class="block no-underline hover:no-underline text-inherit -m-3 p-3"

     

       240
       -
       >

     

       241
       -
         <div class="flex items-center justify-between">

     

       242
       -
           <div class="flex items-center gap-2 min-w-0 flex-1">

     

       243
       -
             <span class="{{if not .Read}}text-blue-600 dark:text-blue-400{{else}}text-gray-500 dark:text-gray-400{{end}}">

     

       244
       -
               {{ i "bell" "w-4 h-4" }}

     

       245
       -
             </span>

     

       246
       -
       

     

       247
       -
             <div class="min-w-0 flex-1">

     

       248
       -
               <div class="flex items-center gap-1 text-gray-900 dark:text-white">

     

       249
       -
                 <span>New notification</span>

     

       250
       -
                 {{if not .Read}}

     

       251
       -
                   <div class="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0 ml-1"></div>

     

       252
       -
                 {{end}}

     

       253
       -
               </div>

     

       254
       -
             </div>

     

       255
       -
           </div>

     

       256
        
       

     

       257
       -
           <div class="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0 ml-2">

     

       258
       -
             {{ template "repo/fragments/time" .Created }}

     

       259
       -
           </div>

     

       260
       -
         </div>

     

       261
       -
       </a>

     

       262
       -
       {{end}}

···

       1
        
       {{define "notifications/fragments/item"}}

     

       2
       +
         <a href="{{ template "notificationUrl" . }}" class="block no-underline hover:no-underline">

     

       3
       +
           <div 

     

       4
       +
             class="

     

       5
       +
               w-full mx-auto rounded drop-shadow-sm dark:text-white bg-white dark:bg-gray-800 px-2 md:px-6 py-4 transition-colors 

     

       6
       +
               {{if not .Read}}bg-blue-50 dark:bg-blue-800/20 border border-blue-500 dark:border-sky-800{{end}}

     

       7
       +
               flex gap-2 items-center

     

       8
       +
               ">

     

       9
       +
             {{ template "notificationIcon" . }}

     

       10
       +
             <div class="flex-1 w-full flex flex-col gap-1">

     

       11
       +
               <span>{{ template "notificationHeader" . }}</span>

     

       12
       +
               <span class="text-sm text-gray-500 dark:text-gray-400">{{ template "notificationSummary" . }}</span>

     

       13
       +
             </div>

     

       14
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       15
        
           </div>

     

       16
       +
         </a>

     

       0
        
       
     

       17
        
       {{end}}

     

       18
        
       

     

       19
        
       {{ define "notificationIcon" }}

     
···

       64
        
         {{ end }}

     

       65
        
       {{ end }}

     

       66
        
       

     

       67
       +
       {{ define "notificationUrl" }}

     

       68
       +
         {{ $url := "" }}

     

       69
       +
         {{ if eq .Type "repo_starred" }}

     

       70
       +
           {{$url = printf "/%s/%s" (resolve .Repo.Did) .Repo.Name}}

     

       71
       +
         {{ else if .Issue }}

     

       72
       +
           {{$url = printf "/%s/%s/issues/%d" (resolve .Repo.Did) .Repo.Name .Issue.IssueId}}

     

       73
       +
         {{ else if .Pull }}

     

       74
       +
           {{$url = printf "/%s/%s/pulls/%d" (resolve .Repo.Did) .Repo.Name .Pull.PullId}}

     

       75
       +
         {{ else if eq .Type "followed" }}

     

       76
       +
           {{$url = printf "/%s" (resolve .ActorDid)}}

     

       77
       +
         {{ else }}

     

       78
       +
         {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       79
        
       

     

       80
       +
         {{ $url }}

     

       81
       +
       {{ end }}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

+1 -1

appview/pages/templates/layouts/fragments/footer.html

···

       23
        
                 <a href="https://blog.tangled.org" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a>

     

       24
        
                 <a href="https://tangled.org/@tangled.org/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a>

     

       25
        
                 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a>

     

       26
       -
                 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a>

     

       27
        
               </div>

     

       28
        
       

     

       29
        
               <div class="flex flex-col gap-1">

···

       23
        
                 <a href="https://blog.tangled.org" class="{{ $linkStyle }}" target="_blank" rel="noopener noreferrer">{{ i "book-open" $iconStyle }} blog</a>

     

       24
        
                 <a href="https://tangled.org/@tangled.org/core/tree/master/docs" class="{{ $linkStyle }}">{{ i "book" $iconStyle }} docs</a>

     

       25
        
                 <a href="https://tangled.org/@tangled.org/core" class="{{ $linkStyle }}">{{ i "code" $iconStyle }} source</a>

     

       26
       +
                 <a href="https://tangled.org/brand" class="{{ $linkStyle }}">{{ i "paintbrush" $iconStyle }} brand</a>

     

       27
        
               </div>

     

       28
        
       

     

       29
        
               <div class="flex flex-col gap-1">

+2 -2

appview/db/pulls.go

···

       246
        
       	// collect pull source for all pulls that need it

     

       247
        
       	var sourceAts []syntax.ATURI

     

       248
        
       	for _, p := range pulls {

     

       249
       -
       		if p.PullSource.RepoAt != nil {

     

       250
        
       			sourceAts = append(sourceAts, *p.PullSource.RepoAt)

     

       251
        
       		}

     

       252
        
       	}

     
···

       259
        
       		sourceRepoMap[r.RepoAt()] = &r

     

       260
        
       	}

     

       261
        
       	for _, p := range pulls {

     

       262
       -
       		if p.PullSource.RepoAt != nil {

     

       263
        
       			if sourceRepo, ok := sourceRepoMap[*p.PullSource.RepoAt]; ok {

     

       264
        
       				p.PullSource.Repo = sourceRepo

     

       265
        
       			}

···

       246
        
       	// collect pull source for all pulls that need it

     

       247
        
       	var sourceAts []syntax.ATURI

     

       248
        
       	for _, p := range pulls {

     

       249
       +
       		if p.PullSource != nil && p.PullSource.RepoAt != nil {

     

       250
        
       			sourceAts = append(sourceAts, *p.PullSource.RepoAt)

     

       251
        
       		}

     

       252
        
       	}

     
···

       259
        
       		sourceRepoMap[r.RepoAt()] = &r

     

       260
        
       	}

     

       261
        
       	for _, p := range pulls {

     

       262
       +
       		if p.PullSource != nil && p.PullSource.RepoAt != nil {

     

       263
        
       			if sourceRepo, ok := sourceRepoMap[*p.PullSource.RepoAt]; ok {

     

       264
        
       				p.PullSource.Repo = sourceRepo

     

       265
        
       			}

appview/pages/templates/layouts/base.html

···

       14
        
                   <link rel="preconnect" href="https://avatar.tangled.sh" />

     

       15
        
                   <link rel="preconnect" href="https://camo.tangled.sh" />

     

       16
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
                   <!-- preload main font -->

     

       18
        
                   <link rel="preload" href="/static/fonts/InterVariable.woff2" as="font" type="font/woff2" crossorigin />

     

       19

···

       14
        
                   <link rel="preconnect" href="https://avatar.tangled.sh" />

     

       15
        
                   <link rel="preconnect" href="https://camo.tangled.sh" />

     

       16
        
       

     

       17
       +
                   <!-- pwa manifest -->

     

       18
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       19
       +
       

     

       20
        
                   <!-- preload main font -->

     

       21
        
                   <link rel="preload" href="/static/fonts/InterVariable.woff2" as="font" type="font/woff2" crossorigin />

     

       22

appview/pages/templates/user/login.html

···

       8
        
                   <meta property="og:url" content="https://tangled.org/login" />

     

       9
        
                   <meta property="og:description" content="login to for tangled" />

     

       10
        
                   <script src="/static/htmx.min.js"></script>

     

       0
        
       
     

       11
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       12
        
                   <title>login &middot; tangled</title>

     

       13
        
               </head>

···

       8
        
                   <meta property="og:url" content="https://tangled.org/login" />

     

       9
        
                   <meta property="og:description" content="login to for tangled" />

     

       10
        
                   <script src="/static/htmx.min.js"></script>

     

       11
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       12
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       13
        
                   <title>login &middot; tangled</title>

     

       14
        
               </head>

appview/pages/templates/user/signup.html

···

       8
        
                   <meta property="og:url" content="https://tangled.org/signup" />

     

       9
        
                   <meta property="og:description" content="sign up for tangled" />

     

       10
        
                   <script src="/static/htmx.min.js"></script>

     

       0
        
       
     

       11
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       12
        
                   <title>sign up &middot; tangled</title>

     

       13

···

       8
        
                   <meta property="og:url" content="https://tangled.org/signup" />

     

       9
        
                   <meta property="og:description" content="sign up for tangled" />

     

       10
        
                   <script src="/static/htmx.min.js"></script>

     

       11
       +
                   <link rel="manifest" href="/pwa-manifest.json" />

     

       12
        
                   <link rel="stylesheet" href="/static/tw.css?{{ cssContentHash }}" type="text/css" />

     

       13
        
                   <title>sign up &middot; tangled</title>

     

       14

appview/state/router.go

···

       37
        
       	router.Use(middleware.TryRefreshSession())

     

       38
        
       	router.Get("/favicon.svg", s.Favicon)

     

       39
        
       	router.Get("/favicon.ico", s.Favicon)

     

       0
        
       
     

       40
        
       

     

       41
        
       	userRouter := s.UserRouter(&middleware)

     

       42
        
       	standardRouter := s.StandardRouter(&middleware)

···

       37
        
       	router.Use(middleware.TryRefreshSession())

     

       38
        
       	router.Get("/favicon.svg", s.Favicon)

     

       39
        
       	router.Get("/favicon.ico", s.Favicon)

     

       40
       +
       	router.Get("/pwa-manifest.json", s.PWAManifest)

     

       41
        
       

     

       42
        
       	userRouter := s.UserRouter(&middleware)

     

       43
        
       	standardRouter := s.StandardRouter(&middleware)

+14 -1

appview/state/knotstream.go

···

       172
        
       		})

     

       173
        
       	}

     

       174
        
       

     

       175
       -
       	return db.InsertRepoLanguages(d, langs)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       176
        
       }

     

       177
        
       

     

       178
        
       func ingestPipeline(d *db.DB, source ec.Source, msg ec.Message) error {

···

       172
        
       		})

     

       173
        
       	}

     

       174
        
       

     

       175
       +
       	tx, err := d.Begin()

     

       176
       +
       	if err != nil {

     

       177
       +
       		return err

     

       178
       +
       	}

     

       179
       +
       	defer tx.Rollback()

     

       180
       +
       

     

       181
       +
       	// update appview's cache

     

       182
       +
       	err = db.UpdateRepoLanguages(tx, repo.RepoAt(), ref.Short(), langs)

     

       183
       +
       	if err != nil {

     

       184
       +
       		fmt.Printf("failed; %s\n", err)

     

       185
       +
       		// non-fatal

     

       186
       +
       	}

     

       187
       +
       

     

       188
       +
       	return tx.Commit()

     

       189
        
       }

     

       190
        
       

     

       191
        
       func ingestPipeline(d *db.DB, source ec.Source, msg ec.Message) error {