-122

auth/auth.go

··· 1 1 - package auth 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "fmt" 6 6 - "net/http" 7 7 - "time" 8 8 - 9 9 - comatproto "github.com/bluesky-social/indigo/api/atproto" 10 10 - "github.com/bluesky-social/indigo/atproto/identity" 11 11 - "github.com/bluesky-social/indigo/atproto/syntax" 12 12 - "github.com/bluesky-social/indigo/xrpc" 13 13 - "github.com/gorilla/sessions" 14 14 - ) 15 15 - 16 16 - type Auth struct { 17 17 - s sessions.Store 18 18 - } 19 19 - 20 20 - func NewAuth(store sessions.Store) *Auth { 21 21 - return &Auth{store} 22 22 - } 23 23 - 24 24 - func ResolveIdent(ctx context.Context, arg string) (*identity.Identity, error) { 25 25 - id, err := syntax.ParseAtIdentifier(arg) 26 26 - if err != nil { 27 27 - return nil, err 28 28 - } 29 29 - 30 30 - dir := identity.DefaultDirectory() 31 31 - return dir.Lookup(ctx, *id) 32 32 - } 33 33 - 34 34 - func (a *Auth) AuthorizedClient(r *http.Request) (*xrpc.Client, error) { 35 35 - clientSession, err := a.s.Get(r, "bild-session") 36 36 - 37 37 - if err != nil || clientSession.IsNew { 38 38 - return nil, err 39 39 - } 40 40 - 41 41 - did := clientSession.Values["did"].(string) 42 42 - pdsUrl := clientSession.Values["pds"].(string) 43 43 - accessJwt := clientSession.Values["accessJwt"].(string) 44 44 - refreshJwt := clientSession.Values["refreshJwt"].(string) 45 45 - 46 46 - client := &xrpc.Client{ 47 47 - Host: pdsUrl, 48 48 - Auth: &xrpc.AuthInfo{ 49 49 - AccessJwt: accessJwt, 50 50 - RefreshJwt: refreshJwt, 51 51 - Did: did, 52 52 - }, 53 53 - } 54 54 - 55 55 - return client, nil 56 56 - } 57 57 - 58 58 - func (a *Auth) CreateInitialSession(w http.ResponseWriter, r *http.Request, username, appPassword string) (AtSessionCreate, error) { 59 59 - ctx := r.Context() 60 60 - resolved, err := ResolveIdent(ctx, username) 61 61 - if err != nil { 62 62 - return AtSessionCreate{}, fmt.Errorf("invalid handle: %s", err) 63 63 - } 64 64 - 65 65 - pdsUrl := resolved.PDSEndpoint() 66 66 - client := xrpc.Client{ 67 67 - Host: pdsUrl, 68 68 - } 69 69 - 70 70 - atSession, err := comatproto.ServerCreateSession(ctx, &client, &comatproto.ServerCreateSession_Input{ 71 71 - Identifier: resolved.DID.String(), 72 72 - Password: appPassword, 73 73 - }) 74 74 - if err != nil { 75 75 - return AtSessionCreate{}, fmt.Errorf("invalid app password") 76 76 - } 77 77 - 78 78 - return AtSessionCreate{ 79 79 - ServerCreateSession_Output: *atSession, 80 80 - PDSEndpoint: pdsUrl, 81 81 - }, nil 82 82 - } 83 83 - 84 84 - func (a *Auth) StoreSession(r *http.Request, w http.ResponseWriter, atSessionCreate *AtSessionCreate, atSessionRefresh *AtSessionRefresh) error { 85 85 - if atSessionCreate != nil { 86 86 - atSession := atSessionCreate 87 87 - 88 88 - clientSession, _ := a.s.Get(r, "bild-session") 89 89 - clientSession.Values["handle"] = atSession.Handle 90 90 - clientSession.Values["did"] = atSession.Did 91 91 - clientSession.Values["accessJwt"] = atSession.AccessJwt 92 92 - clientSession.Values["refreshJwt"] = atSession.RefreshJwt 93 93 - clientSession.Values["expiry"] = time.Now().Add(time.Hour).String() 94 94 - clientSession.Values["pds"] = atSession.PDSEndpoint 95 95 - clientSession.Values["authenticated"] = true 96 96 - 97 97 - return clientSession.Save(r, w) 98 98 - } else { 99 99 - atSession := atSessionRefresh 100 100 - 101 101 - clientSession, _ := a.s.Get(r, "bild-session") 102 102 - clientSession.Values["handle"] = atSession.Handle 103 103 - clientSession.Values["did"] = atSession.Did 104 104 - clientSession.Values["accessJwt"] = atSession.AccessJwt 105 105 - clientSession.Values["refreshJwt"] = atSession.RefreshJwt 106 106 - clientSession.Values["expiry"] = time.Now().Add(time.Hour).String() 107 107 - clientSession.Values["pds"] = atSession.PDSEndpoint 108 108 - clientSession.Values["authenticated"] = true 109 109 - 110 110 - return clientSession.Save(r, w) 111 111 - } 112 112 - } 113 113 - 114 114 - func (a *Auth) GetSessionUser(r *http.Request) (*identity.Identity, error) { 115 115 - session, _ := a.s.Get(r, "bild-session") 116 116 - did, ok := session.Values["did"].(string) 117 117 - if !ok { 118 118 - return nil, fmt.Errorf("user is not authenticated") 119 119 - } 120 120 - 121 121 - return ResolveIdent(r.Context(), did) 122 122 - }

-15

auth/types.go

··· 1 1 - package auth 2 2 - 3 3 - import ( 4 4 - comatproto "github.com/bluesky-social/indigo/api/atproto" 5 5 - ) 6 6 - 7 7 - type AtSessionCreate struct { 8 8 - comatproto.ServerCreateSession_Output 9 9 - PDSEndpoint string 10 10 - } 11 11 - 12 12 - type AtSessionRefresh struct { 13 13 - comatproto.ServerRefreshSession_Output 14 14 - PDSEndpoint string 15 15 - }

-47

cmd/legit/main.go

··· 1 1 - package main 2 2 - 3 3 - import ( 4 4 - "flag" 5 5 - "fmt" 6 6 - "log" 7 7 - "log/slog" 8 8 - "net/http" 9 9 - "os" 10 10 - 11 11 - "github.com/icyphox/bild/config" 12 12 - "github.com/icyphox/bild/db" 13 13 - "github.com/icyphox/bild/routes" 14 14 - ) 15 15 - 16 16 - func main() { 17 17 - var cfg string 18 18 - flag.StringVar(&cfg, "config", "./config.yaml", "path to config file") 19 19 - flag.Parse() 20 20 - 21 21 - slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, nil))) 22 22 - 23 23 - c, err := config.Read(cfg) 24 24 - if err != nil { 25 25 - log.Fatal(err) 26 26 - } 27 27 - db, err := db.Setup(c.Server.DBPath) 28 28 - if err != nil { 29 29 - log.Fatalf("failed to setup db: %s", err) 30 30 - } 31 31 - 32 32 - mux, err := routes.Setup(c, db) 33 33 - if err != nil { 34 34 - log.Fatal(err) 35 35 - } 36 36 - 37 37 - internalMux := routes.SetupInternal(c, db) 38 38 - 39 39 - addr := fmt.Sprintf("%s:%d", c.Server.Host, c.Server.Port) 40 40 - internalAddr := fmt.Sprintf("%s:%d", c.Server.InternalHost, c.Server.InternalPort) 41 41 - 42 42 - log.Println("starting main server on", addr) 43 43 - go http.ListenAndServe(addr, mux) 44 44 - 45 45 - log.Println("starting internal server on", internalAddr) 46 46 - log.Fatal(http.ListenAndServe(internalAddr, internalMux)) 47 47 - }

-61

config/config.go

··· 1 1 - package config 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "os" 6 6 - "path/filepath" 7 7 - 8 8 - "gopkg.in/yaml.v3" 9 9 - ) 10 10 - 11 11 - type Config struct { 12 12 - Repo struct { 13 13 - ScanPath string `yaml:"scanPath"` 14 14 - Readme []string `yaml:"readme"` 15 15 - MainBranch []string `yaml:"mainBranch"` 16 16 - Ignore []string `yaml:"ignore,omitempty"` 17 17 - Unlisted []string `yaml:"unlisted,omitempty"` 18 18 - } `yaml:"repo"` 19 19 - Dirs struct { 20 20 - Templates string `yaml:"templates"` 21 21 - Static string `yaml:"static"` 22 22 - } `yaml:"dirs"` 23 23 - Meta struct { 24 24 - Title string `yaml:"title"` 25 25 - Description string `yaml:"description"` 26 26 - SyntaxHighlight string `yaml:"syntaxHighlight"` 27 27 - } `yaml:"meta"` 28 28 - Server struct { 29 29 - Name string `yaml:"name,omitempty"` 30 30 - Host string `yaml:"host"` 31 31 - Port int `yaml:"port"` 32 32 - DBPath string `yaml:"dbpath"` 33 33 - 34 34 - InternalHost string `yaml:"internalHost,omitempty"` 35 35 - InternalPort int `yaml:"internalPort,omitempty"` 36 36 - } `yaml:"server"` 37 37 - } 38 38 - 39 39 - func Read(f string) (*Config, error) { 40 40 - b, err := os.ReadFile(f) 41 41 - if err != nil { 42 42 - return nil, fmt.Errorf("reading config: %w", err) 43 43 - } 44 44 - 45 45 - c := Config{} 46 46 - if err := yaml.Unmarshal(b, &c); err != nil { 47 47 - return nil, fmt.Errorf("parsing config: %w", err) 48 48 - } 49 49 - 50 50 - if c.Repo.ScanPath, err = filepath.Abs(c.Repo.ScanPath); err != nil { 51 51 - return nil, err 52 52 - } 53 53 - if c.Dirs.Templates, err = filepath.Abs(c.Dirs.Templates); err != nil { 54 54 - return nil, err 55 55 - } 56 56 - if c.Dirs.Static, err = filepath.Abs(c.Dirs.Static); err != nil { 57 57 - return nil, err 58 58 - } 59 59 - 60 60 - return &c, nil 61 61 - }

-22

contrib/Dockerfile

··· 1 1 - FROM golang:1.22-alpine AS builder 2 2 - 3 3 - WORKDIR /app 4 4 - 5 5 - COPY . . 6 6 - RUN go mod download 7 7 - RUN go mod verify 8 8 - 9 9 - RUN go build -o legit 10 10 - 11 11 - FROM scratch AS build-release-stage 12 12 - 13 13 - WORKDIR /app 14 14 - 15 15 - COPY static ./static 16 16 - COPY templates ./templates 17 17 - COPY config.yaml ./ 18 18 - COPY --from=builder /app/legit ./ 19 19 - 20 20 - EXPOSE 5555 21 21 - 22 22 - CMD ["./legit"]

-14

contrib/docker-compose.yml

··· 1 1 - services: 2 2 - legit: 3 3 - container_name: legit 4 4 - build: 5 5 - context: ../ 6 6 - dockerfile: contrib/Dockerfile 7 7 - restart: unless-stopped 8 8 - ports: 9 9 - - "5555:5555" 10 10 - volumes: 11 11 - - /var/www/git:/var/www/git 12 12 - - ../config.yaml:/app/config.yaml 13 13 - - ../static:/app/static 14 14 - - ../templates:/app/templates

-17

contrib/legit.service

··· 1 1 - [Unit] 2 2 - Description=legit Server 3 3 - After=network-online.target 4 4 - Requires=network-online.target 5 5 - 6 6 - [Service] 7 7 - User=git 8 8 - Group=git 9 9 - ExecStart=/usr/bin/legit -config /etc/legit/config.yaml 10 10 - ProtectSystem=strict 11 11 - ProtectHome=strict 12 12 - NoNewPrivileges=true 13 13 - PrivateTmp=true 14 14 - PrivateDevices=true 15 15 - 16 16 - [Install] 17 17 - WantedBy=multi-user.target

-80

db/access.go

··· 1 1 - package db 2 2 - 3 3 - import ( 4 4 - "log" 5 5 - "strings" 6 6 - ) 7 7 - 8 8 - // forms a poset 9 9 - type Level int 10 10 - 11 11 - const ( 12 12 - Reader Level = iota 13 13 - Writer 14 14 - Owner 15 15 - ) 16 16 - 17 17 - var ( 18 18 - levelMap = map[string]Level{ 19 19 - "writer": Writer, 20 20 - "owner": Owner, 21 21 - } 22 22 - ) 23 23 - 24 24 - func ParseLevel(str string) (Level, bool) { 25 25 - c, ok := levelMap[strings.ToLower(str)] 26 26 - return c, ok 27 27 - } 28 28 - 29 29 - func (l Level) String() string { 30 30 - switch l { 31 31 - case Owner: 32 32 - return "OWNER" 33 33 - case Writer: 34 34 - return "WRITER" 35 35 - case Reader: 36 36 - return "READER" 37 37 - default: 38 38 - return "READER" 39 39 - } 40 40 - } 41 41 - 42 42 - func (d *DB) SetAccessLevel(userDid string, repoDid string, repoName string, level Level) error { 43 43 - _, err := d.db.Exec( 44 44 - `insert 45 45 - into access_levels (repo_id, did, access) 46 46 - values ((select id from repos where did = $1 and name = $2), $3, $4) 47 47 - on conflict (repo_id, did) 48 48 - do update set access = $4;`, 49 49 - repoDid, repoName, userDid, level.String()) 50 50 - return err 51 51 - } 52 52 - 53 53 - func (d *DB) SetOwner(userDid string, repoDid string, repoName string) error { 54 54 - return d.SetAccessLevel(userDid, repoDid, repoName, Owner) 55 55 - } 56 56 - 57 57 - func (d *DB) SetWriter(userDid string, repoDid string, repoName string) error { 58 58 - return d.SetAccessLevel(userDid, repoDid, repoName, Writer) 59 59 - } 60 60 - 61 61 - func (d *DB) GetAccessLevel(userDid string, repoDid string, repoName string) (Level, error) { 62 62 - row := d.db.QueryRow(` 63 63 - select access_levels.access 64 64 - from repos 65 65 - join access_levels 66 66 - on repos.id = access_levels.repo_id 67 67 - where access_levels.did = ? and repos.did = ? and repos.name = ? 68 68 - `, userDid, repoDid, repoName) 69 69 - 70 70 - var levelStr string 71 71 - err := row.Scan(&levelStr) 72 72 - if err != nil { 73 73 - log.Println(err) 74 74 - return Reader, err 75 75 - } else { 76 76 - level, _ := ParseLevel(levelStr) 77 77 - return level, nil 78 78 - } 79 79 - 80 80 - }

-51

db/init.go

··· 1 1 - package db 2 2 - 3 3 - import ( 4 4 - "database/sql" 5 5 - 6 6 - _ "github.com/mattn/go-sqlite3" 7 7 - ) 8 8 - 9 9 - type DB struct { 10 10 - db *sql.DB 11 11 - } 12 12 - 13 13 - func Setup(dbPath string) (*DB, error) { 14 14 - db, err := sql.Open("sqlite3", dbPath) 15 15 - if err != nil { 16 16 - return nil, err 17 17 - } 18 18 - 19 19 - _, err = db.Exec(` 20 20 - create table if not exists public_keys ( 21 21 - id integer primary key autoincrement, 22 22 - did text not null, 23 23 - name text not null, 24 24 - key text not null, 25 25 - created timestamp default current_timestamp, 26 26 - unique(did, name, key) 27 27 - ); 28 28 - create table if not exists repos ( 29 29 - id integer primary key autoincrement, 30 30 - did text not null, 31 31 - name text not null, 32 32 - description text not null, 33 33 - created timestamp default current_timestamp, 34 34 - unique(did, name) 35 35 - ); 36 36 - create table if not exists access_levels ( 37 37 - id integer primary key autoincrement, 38 38 - repo_id integer not null, 39 39 - did text not null, 40 40 - access text not null check (access in ('OWNER', 'WRITER')), 41 41 - created timestamp default current_timestamp, 42 42 - unique(repo_id, did), 43 43 - foreign key (repo_id) references repos(id) on delete cascade 44 44 - ); 45 45 - `) 46 46 - if err != nil { 47 47 - return nil, err 48 48 - } 49 49 - 50 50 - return &DB{db: db}, nil 51 51 - }

-70

db/pubkeys.go

··· 1 1 - package db 2 2 - 3 3 - import "time" 4 4 - 5 5 - func (d *DB) AddPublicKey(did, name, key string) error { 6 6 - query := `insert into public_keys (did, name, key) values (?, ?, ?)` 7 7 - _, err := d.db.Exec(query, did, name, key) 8 8 - return err 9 9 - } 10 10 - 11 11 - func (d *DB) RemovePublicKey(did string) error { 12 12 - query := `delete from public_keys where did = ?` 13 13 - _, err := d.db.Exec(query, did) 14 14 - return err 15 15 - } 16 16 - 17 17 - type PublicKey struct { 18 18 - Key string 19 19 - Name string 20 20 - DID string 21 21 - Created time.Time 22 22 - } 23 23 - 24 24 - func (d *DB) GetAllPublicKeys() ([]PublicKey, error) { 25 25 - var keys []PublicKey 26 26 - 27 27 - rows, err := d.db.Query(`select key, name, did, created from public_keys`) 28 28 - if err != nil { 29 29 - return nil, err 30 30 - } 31 31 - defer rows.Close() 32 32 - 33 33 - for rows.Next() { 34 34 - var publicKey PublicKey 35 35 - if err := rows.Scan(&publicKey.Key, &publicKey.Name, &publicKey.DID, &publicKey.Created); err != nil { 36 36 - return nil, err 37 37 - } 38 38 - keys = append(keys, publicKey) 39 39 - } 40 40 - 41 41 - if err := rows.Err(); err != nil { 42 42 - return nil, err 43 43 - } 44 44 - 45 45 - return keys, nil 46 46 - } 47 47 - 48 48 - func (d *DB) GetPublicKeys(did string) ([]PublicKey, error) { 49 49 - var keys []PublicKey 50 50 - 51 51 - rows, err := d.db.Query(`select did, key, name, created from public_keys where did = ?`, did) 52 52 - if err != nil { 53 53 - return nil, err 54 54 - } 55 55 - defer rows.Close() 56 56 - 57 57 - for rows.Next() { 58 58 - var publicKey PublicKey 59 59 - if err := rows.Scan(&publicKey.DID, &publicKey.Key, &publicKey.Name, &publicKey.Created); err != nil { 60 60 - return nil, err 61 61 - } 62 62 - keys = append(keys, publicKey) 63 63 - } 64 64 - 65 65 - if err := rows.Err(); err != nil { 66 66 - return nil, err 67 67 - } 68 68 - 69 69 - return keys, nil 70 70 - }

-25

db/repo.go

··· 1 1 - package db 2 2 - 3 3 - func (d *DB) AddRepo(did string, name string, description string) error { 4 4 - _, err := d.db.Exec("insert into repos (did, name, description) values (?, ?, ?)", did, name, description) 5 5 - if err != nil { 6 6 - return err 7 7 - } 8 8 - return nil 9 9 - } 10 10 - 11 11 - func (d *DB) RemoveRepo(did string) error { 12 12 - _, err := d.db.Exec("delete from repos where did = ?", did) 13 13 - if err != nil { 14 14 - return err 15 15 - } 16 16 - return nil 17 17 - } 18 18 - 19 19 - func (d *DB) UpdateRepo(did string, name string, description string) error { 20 20 - _, err := d.db.Exec("update repos set name = ?, description = ? where did = ?", name, description, did) 21 21 - if err != nil { 22 22 - return err 23 23 - } 24 24 - return nil 25 25 - }

-119

git/diff.go

··· 1 1 - package git 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "log" 6 6 - "strings" 7 7 - 8 8 - "github.com/bluekeyes/go-gitdiff/gitdiff" 9 9 - "github.com/go-git/go-git/v5/plumbing/object" 10 10 - ) 11 11 - 12 12 - type TextFragment struct { 13 13 - Header string 14 14 - Lines []gitdiff.Line 15 15 - } 16 16 - 17 17 - type Diff struct { 18 18 - Name struct { 19 19 - Old string 20 20 - New string 21 21 - } 22 22 - TextFragments []TextFragment 23 23 - IsBinary bool 24 24 - IsNew bool 25 25 - IsDelete bool 26 26 - } 27 27 - 28 28 - // A nicer git diff representation. 29 29 - type NiceDiff struct { 30 30 - Commit struct { 31 31 - Message string 32 32 - Author object.Signature 33 33 - This string 34 34 - Parent string 35 35 - } 36 36 - Stat struct { 37 37 - FilesChanged int 38 38 - Insertions int 39 39 - Deletions int 40 40 - } 41 41 - Diff []Diff 42 42 - } 43 43 - 44 44 - func (g *GitRepo) Diff() (*NiceDiff, error) { 45 45 - c, err := g.r.CommitObject(g.h) 46 46 - if err != nil { 47 47 - return nil, fmt.Errorf("commit object: %w", err) 48 48 - } 49 49 - 50 50 - patch := &object.Patch{} 51 51 - commitTree, err := c.Tree() 52 52 - parent := &object.Commit{} 53 53 - if err == nil { 54 54 - parentTree := &object.Tree{} 55 55 - if c.NumParents() != 0 { 56 56 - parent, err = c.Parents().Next() 57 57 - if err == nil { 58 58 - parentTree, err = parent.Tree() 59 59 - if err == nil { 60 60 - patch, err = parentTree.Patch(commitTree) 61 61 - if err != nil { 62 62 - return nil, fmt.Errorf("patch: %w", err) 63 63 - } 64 64 - } 65 65 - } 66 66 - } else { 67 67 - patch, err = parentTree.Patch(commitTree) 68 68 - if err != nil { 69 69 - return nil, fmt.Errorf("patch: %w", err) 70 70 - } 71 71 - } 72 72 - } 73 73 - 74 74 - diffs, _, err := gitdiff.Parse(strings.NewReader(patch.String())) 75 75 - if err != nil { 76 76 - log.Println(err) 77 77 - } 78 78 - 79 79 - nd := NiceDiff{} 80 80 - nd.Commit.This = c.Hash.String() 81 81 - 82 82 - if parent.Hash.IsZero() { 83 83 - nd.Commit.Parent = "" 84 84 - } else { 85 85 - nd.Commit.Parent = parent.Hash.String() 86 86 - } 87 87 - nd.Commit.Author = c.Author 88 88 - nd.Commit.Message = c.Message 89 89 - 90 90 - for _, d := range diffs { 91 91 - ndiff := Diff{} 92 92 - ndiff.Name.New = d.NewName 93 93 - ndiff.Name.Old = d.OldName 94 94 - ndiff.IsBinary = d.IsBinary 95 95 - ndiff.IsNew = d.IsNew 96 96 - ndiff.IsDelete = d.IsDelete 97 97 - 98 98 - for _, tf := range d.TextFragments { 99 99 - ndiff.TextFragments = append(ndiff.TextFragments, TextFragment{ 100 100 - Header: tf.Header(), 101 101 - Lines: tf.Lines, 102 102 - }) 103 103 - for _, l := range tf.Lines { 104 104 - switch l.Op { 105 105 - case gitdiff.OpAdd: 106 106 - nd.Stat.Insertions += 1 107 107 - case gitdiff.OpDelete: 108 108 - nd.Stat.Deletions += 1 109 109 - } 110 110 - } 111 111 - } 112 112 - 113 113 - nd.Diff = append(nd.Diff, ndiff) 114 114 - } 115 115 - 116 116 - nd.Stat.FilesChanged = len(diffs) 117 117 - 118 118 - return &nd, nil 119 119 - }

-345

git/git.go

··· 1 1 - package git 2 2 - 3 3 - import ( 4 4 - "archive/tar" 5 5 - "fmt" 6 6 - "io" 7 7 - "io/fs" 8 8 - "path" 9 9 - "sort" 10 10 - "time" 11 11 - 12 12 - "github.com/go-git/go-git/v5" 13 13 - "github.com/go-git/go-git/v5/plumbing" 14 14 - "github.com/go-git/go-git/v5/plumbing/object" 15 15 - ) 16 16 - 17 17 - type GitRepo struct { 18 18 - r *git.Repository 19 19 - h plumbing.Hash 20 20 - } 21 21 - 22 22 - type TagList struct { 23 23 - refs []*TagReference 24 24 - r *git.Repository 25 25 - } 26 26 - 27 27 - // TagReference is used to list both tag and non-annotated tags. 28 28 - // Non-annotated tags should only contains a reference. 29 29 - // Annotated tags should contain its reference and its tag information. 30 30 - type TagReference struct { 31 31 - ref *plumbing.Reference 32 32 - tag *object.Tag 33 33 - } 34 34 - 35 35 - // infoWrapper wraps the property of a TreeEntry so it can export fs.FileInfo 36 36 - // to tar WriteHeader 37 37 - type infoWrapper struct { 38 38 - name string 39 39 - size int64 40 40 - mode fs.FileMode 41 41 - modTime time.Time 42 42 - isDir bool 43 43 - } 44 44 - 45 45 - func (self *TagList) Len() int { 46 46 - return len(self.refs) 47 47 - } 48 48 - 49 49 - func (self *TagList) Swap(i, j int) { 50 50 - self.refs[i], self.refs[j] = self.refs[j], self.refs[i] 51 51 - } 52 52 - 53 53 - // sorting tags in reverse chronological order 54 54 - func (self *TagList) Less(i, j int) bool { 55 55 - var dateI time.Time 56 56 - var dateJ time.Time 57 57 - 58 58 - if self.refs[i].tag != nil { 59 59 - dateI = self.refs[i].tag.Tagger.When 60 60 - } else { 61 61 - c, err := self.r.CommitObject(self.refs[i].ref.Hash()) 62 62 - if err != nil { 63 63 - dateI = time.Now() 64 64 - } else { 65 65 - dateI = c.Committer.When 66 66 - } 67 67 - } 68 68 - 69 69 - if self.refs[j].tag != nil { 70 70 - dateJ = self.refs[j].tag.Tagger.When 71 71 - } else { 72 72 - c, err := self.r.CommitObject(self.refs[j].ref.Hash()) 73 73 - if err != nil { 74 74 - dateJ = time.Now() 75 75 - } else { 76 76 - dateJ = c.Committer.When 77 77 - } 78 78 - } 79 79 - 80 80 - return dateI.After(dateJ) 81 81 - } 82 82 - 83 83 - func Open(path string, ref string) (*GitRepo, error) { 84 84 - var err error 85 85 - g := GitRepo{} 86 86 - g.r, err = git.PlainOpen(path) 87 87 - if err != nil { 88 88 - return nil, fmt.Errorf("opening %s: %w", path, err) 89 89 - } 90 90 - 91 91 - if ref == "" { 92 92 - head, err := g.r.Head() 93 93 - if err != nil { 94 94 - return nil, fmt.Errorf("getting head of %s: %w", path, err) 95 95 - } 96 96 - g.h = head.Hash() 97 97 - } else { 98 98 - hash, err := g.r.ResolveRevision(plumbing.Revision(ref)) 99 99 - if err != nil { 100 100 - return nil, fmt.Errorf("resolving rev %s for %s: %w", ref, path, err) 101 101 - } 102 102 - g.h = *hash 103 103 - } 104 104 - return &g, nil 105 105 - } 106 106 - 107 107 - func (g *GitRepo) Commits() ([]*object.Commit, error) { 108 108 - ci, err := g.r.Log(&git.LogOptions{From: g.h}) 109 109 - if err != nil { 110 110 - return nil, fmt.Errorf("commits from ref: %w", err) 111 111 - } 112 112 - 113 113 - commits := []*object.Commit{} 114 114 - ci.ForEach(func(c *object.Commit) error { 115 115 - commits = append(commits, c) 116 116 - return nil 117 117 - }) 118 118 - 119 119 - return commits, nil 120 120 - } 121 121 - 122 122 - func (g *GitRepo) LastCommit() (*object.Commit, error) { 123 123 - c, err := g.r.CommitObject(g.h) 124 124 - if err != nil { 125 125 - return nil, fmt.Errorf("last commit: %w", err) 126 126 - } 127 127 - return c, nil 128 128 - } 129 129 - 130 130 - func (g *GitRepo) FileContent(path string) (string, error) { 131 131 - c, err := g.r.CommitObject(g.h) 132 132 - if err != nil { 133 133 - return "", fmt.Errorf("commit object: %w", err) 134 134 - } 135 135 - 136 136 - tree, err := c.Tree() 137 137 - if err != nil { 138 138 - return "", fmt.Errorf("file tree: %w", err) 139 139 - } 140 140 - 141 141 - file, err := tree.File(path) 142 142 - if err != nil { 143 143 - return "", err 144 144 - } 145 145 - 146 146 - isbin, _ := file.IsBinary() 147 147 - 148 148 - if !isbin { 149 149 - return file.Contents() 150 150 - } else { 151 151 - return "Not displaying binary file", nil 152 152 - } 153 153 - } 154 154 - 155 155 - func (g *GitRepo) Tags() ([]*TagReference, error) { 156 156 - iter, err := g.r.Tags() 157 157 - if err != nil { 158 158 - return nil, fmt.Errorf("tag objects: %w", err) 159 159 - } 160 160 - 161 161 - tags := make([]*TagReference, 0) 162 162 - 163 163 - if err := iter.ForEach(func(ref *plumbing.Reference) error { 164 164 - obj, err := g.r.TagObject(ref.Hash()) 165 165 - switch err { 166 166 - case nil: 167 167 - tags = append(tags, &TagReference{ 168 168 - ref: ref, 169 169 - tag: obj, 170 170 - }) 171 171 - case plumbing.ErrObjectNotFound: 172 172 - tags = append(tags, &TagReference{ 173 173 - ref: ref, 174 174 - }) 175 175 - default: 176 176 - return err 177 177 - } 178 178 - return nil 179 179 - }); err != nil { 180 180 - return nil, err 181 181 - } 182 182 - 183 183 - tagList := &TagList{r: g.r, refs: tags} 184 184 - sort.Sort(tagList) 185 185 - return tags, nil 186 186 - } 187 187 - 188 188 - func (g *GitRepo) Branches() ([]*plumbing.Reference, error) { 189 189 - bi, err := g.r.Branches() 190 190 - if err != nil { 191 191 - return nil, fmt.Errorf("branchs: %w", err) 192 192 - } 193 193 - 194 194 - branches := []*plumbing.Reference{} 195 195 - 196 196 - _ = bi.ForEach(func(ref *plumbing.Reference) error { 197 197 - branches = append(branches, ref) 198 198 - return nil 199 199 - }) 200 200 - 201 201 - return branches, nil 202 202 - } 203 203 - 204 204 - func (g *GitRepo) FindMainBranch(branches []string) (string, error) { 205 205 - 206 206 - for _, b := range branches { 207 207 - _, err := g.r.ResolveRevision(plumbing.Revision(b)) 208 208 - if err == nil { 209 209 - return b, nil 210 210 - } 211 211 - } 212 212 - return "", fmt.Errorf("unable to find main branch") 213 213 - } 214 214 - 215 215 - // WriteTar writes itself from a tree into a binary tar file format. 216 216 - // prefix is root folder to be appended. 217 217 - func (g *GitRepo) WriteTar(w io.Writer, prefix string) error { 218 218 - tw := tar.NewWriter(w) 219 219 - defer tw.Close() 220 220 - 221 221 - c, err := g.r.CommitObject(g.h) 222 222 - if err != nil { 223 223 - return fmt.Errorf("commit object: %w", err) 224 224 - } 225 225 - 226 226 - tree, err := c.Tree() 227 227 - if err != nil { 228 228 - return err 229 229 - } 230 230 - 231 231 - walker := object.NewTreeWalker(tree, true, nil) 232 232 - defer walker.Close() 233 233 - 234 234 - name, entry, err := walker.Next() 235 235 - for ; err == nil; name, entry, err = walker.Next() { 236 236 - info, err := newInfoWrapper(name, prefix, &entry, tree) 237 237 - if err != nil { 238 238 - return err 239 239 - } 240 240 - 241 241 - header, err := tar.FileInfoHeader(info, "") 242 242 - if err != nil { 243 243 - return err 244 244 - } 245 245 - 246 246 - err = tw.WriteHeader(header) 247 247 - if err != nil { 248 248 - return err 249 249 - } 250 250 - 251 251 - if !info.IsDir() { 252 252 - file, err := tree.File(name) 253 253 - if err != nil { 254 254 - return err 255 255 - } 256 256 - 257 257 - reader, err := file.Blob.Reader() 258 258 - if err != nil { 259 259 - return err 260 260 - } 261 261 - 262 262 - _, err = io.Copy(tw, reader) 263 263 - if err != nil { 264 264 - reader.Close() 265 265 - return err 266 266 - } 267 267 - reader.Close() 268 268 - } 269 269 - } 270 270 - 271 271 - return nil 272 272 - } 273 273 - 274 274 - func newInfoWrapper( 275 275 - name string, 276 276 - prefix string, 277 277 - entry *object.TreeEntry, 278 278 - tree *object.Tree, 279 279 - ) (*infoWrapper, error) { 280 280 - var ( 281 281 - size int64 282 282 - mode fs.FileMode 283 283 - isDir bool 284 284 - ) 285 285 - 286 286 - if entry.Mode.IsFile() { 287 287 - file, err := tree.TreeEntryFile(entry) 288 288 - if err != nil { 289 289 - return nil, err 290 290 - } 291 291 - mode = fs.FileMode(file.Mode) 292 292 - 293 293 - size, err = tree.Size(name) 294 294 - if err != nil { 295 295 - return nil, err 296 296 - } 297 297 - } else { 298 298 - isDir = true 299 299 - mode = fs.ModeDir | fs.ModePerm 300 300 - } 301 301 - 302 302 - fullname := path.Join(prefix, name) 303 303 - return &infoWrapper{ 304 304 - name: fullname, 305 305 - size: size, 306 306 - mode: mode, 307 307 - modTime: time.Unix(0, 0), 308 308 - isDir: isDir, 309 309 - }, nil 310 310 - } 311 311 - 312 312 - func (i *infoWrapper) Name() string { 313 313 - return i.name 314 314 - } 315 315 - 316 316 - func (i *infoWrapper) Size() int64 { 317 317 - return i.size 318 318 - } 319 319 - 320 320 - func (i *infoWrapper) Mode() fs.FileMode { 321 321 - return i.mode 322 322 - } 323 323 - 324 324 - func (i *infoWrapper) ModTime() time.Time { 325 325 - return i.modTime 326 326 - } 327 327 - 328 328 - func (i *infoWrapper) IsDir() bool { 329 329 - return i.isDir 330 330 - } 331 331 - 332 332 - func (i *infoWrapper) Sys() any { 333 333 - return nil 334 334 - } 335 335 - 336 336 - func (t *TagReference) Name() string { 337 337 - return t.ref.Name().Short() 338 338 - } 339 339 - 340 340 - func (t *TagReference) Message() string { 341 341 - if t.tag != nil { 342 342 - return t.tag.Message 343 343 - } 344 344 - return "" 345 345 - }

-33

git/repo.go

··· 1 1 - package git 2 2 - 3 3 - import ( 4 4 - "errors" 5 5 - "fmt" 6 6 - "os" 7 7 - "path/filepath" 8 8 - 9 9 - gogit "github.com/go-git/go-git/v5" 10 10 - "github.com/go-git/go-git/v5/config" 11 11 - ) 12 12 - 13 13 - func InitBare(path string) error { 14 14 - parent := filepath.Dir(path) 15 15 - 16 16 - if err := os.MkdirAll(parent, 0755); errors.Is(err, os.ErrExist) { 17 17 - return fmt.Errorf("error creating user directory: %w", err) 18 18 - } 19 19 - 20 20 - repository, err := gogit.PlainInit(path, true) 21 21 - if err != nil { 22 22 - return err 23 23 - } 24 24 - 25 25 - err = repository.CreateBranch(&config.Branch{ 26 26 - Name: "main", 27 27 - }) 28 28 - if err != nil { 29 29 - return fmt.Errorf("creating branch: %w", err) 30 30 - } 31 31 - 32 32 - return nil 33 33 - }

-121

git/service/service.go

··· 1 1 - package service 2 2 - 3 3 - import ( 4 4 - "bytes" 5 5 - "fmt" 6 6 - "io" 7 7 - "log" 8 8 - "net/http" 9 9 - "os/exec" 10 10 - "strings" 11 11 - "syscall" 12 12 - ) 13 13 - 14 14 - // Mostly from charmbracelet/soft-serve and sosedoff/gitkit. 15 15 - 16 16 - type ServiceCommand struct { 17 17 - Dir string 18 18 - Stdin io.Reader 19 19 - Stdout http.ResponseWriter 20 20 - } 21 21 - 22 22 - func (c *ServiceCommand) InfoRefs() error { 23 23 - cmd := exec.Command("git", []string{ 24 24 - "upload-pack", 25 25 - "--stateless-rpc", 26 26 - "--advertise-refs", 27 27 - ".", 28 28 - }...) 29 29 - 30 30 - cmd.Dir = c.Dir 31 31 - cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} 32 32 - stdoutPipe, _ := cmd.StdoutPipe() 33 33 - cmd.Stderr = cmd.Stdout 34 34 - 35 35 - if err := cmd.Start(); err != nil { 36 36 - log.Printf("git: failed to start git-upload-pack (info/refs): %s", err) 37 37 - return err 38 38 - } 39 39 - 40 40 - if err := packLine(c.Stdout, "# service=git-upload-pack\n"); err != nil { 41 41 - log.Printf("git: failed to write pack line: %s", err) 42 42 - return err 43 43 - } 44 44 - 45 45 - if err := packFlush(c.Stdout); err != nil { 46 46 - log.Printf("git: failed to flush pack: %s", err) 47 47 - return err 48 48 - } 49 49 - 50 50 - buf := bytes.Buffer{} 51 51 - if _, err := io.Copy(&buf, stdoutPipe); err != nil { 52 52 - log.Printf("git: failed to copy stdout to tmp buffer: %s", err) 53 53 - return err 54 54 - } 55 55 - 56 56 - if err := cmd.Wait(); err != nil { 57 57 - out := strings.Builder{} 58 58 - _, _ = io.Copy(&out, &buf) 59 59 - log.Printf("git: failed to run git-upload-pack; err: %s; output: %s", err, out.String()) 60 60 - return err 61 61 - } 62 62 - 63 63 - if _, err := io.Copy(c.Stdout, &buf); err != nil { 64 64 - log.Printf("git: failed to copy stdout: %s", err) 65 65 - } 66 66 - 67 67 - return nil 68 68 - } 69 69 - 70 70 - func (c *ServiceCommand) UploadPack() error { 71 71 - cmd := exec.Command("git", []string{ 72 72 - "-c", "uploadpack.allowFilter=true", 73 73 - "upload-pack", 74 74 - "--stateless-rpc", 75 75 - ".", 76 76 - }...) 77 77 - cmd.Dir = c.Dir 78 78 - cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} 79 79 - 80 80 - stdoutPipe, _ := cmd.StdoutPipe() 81 81 - cmd.Stderr = cmd.Stdout 82 82 - defer stdoutPipe.Close() 83 83 - 84 84 - stdinPipe, err := cmd.StdinPipe() 85 85 - if err != nil { 86 86 - return err 87 87 - } 88 88 - defer stdinPipe.Close() 89 89 - 90 90 - if err := cmd.Start(); err != nil { 91 91 - log.Printf("git: failed to start git-upload-pack: %s", err) 92 92 - return err 93 93 - } 94 94 - 95 95 - if _, err := io.Copy(stdinPipe, c.Stdin); err != nil { 96 96 - log.Printf("git: failed to copy stdin: %s", err) 97 97 - return err 98 98 - } 99 99 - stdinPipe.Close() 100 100 - 101 101 - if _, err := io.Copy(newWriteFlusher(c.Stdout), stdoutPipe); err != nil { 102 102 - log.Printf("git: failed to copy stdout: %s", err) 103 103 - return err 104 104 - } 105 105 - if err := cmd.Wait(); err != nil { 106 106 - log.Printf("git: failed to wait for git-upload-pack: %s", err) 107 107 - return err 108 108 - } 109 109 - 110 110 - return nil 111 111 - } 112 112 - 113 113 - func packLine(w io.Writer, s string) error { 114 114 - _, err := fmt.Fprintf(w, "%04x%s", len(s)+4, s) 115 115 - return err 116 116 - } 117 117 - 118 118 - func packFlush(w io.Writer) error { 119 119 - _, err := fmt.Fprint(w, "0000") 120 120 - return err 121 121 - }

-25

git/service/write_flusher.go

··· 1 1 - package service 2 2 - 3 3 - import ( 4 4 - "io" 5 5 - "net/http" 6 6 - ) 7 7 - 8 8 - func newWriteFlusher(w http.ResponseWriter) io.Writer { 9 9 - return writeFlusher{w.(interface { 10 10 - io.Writer 11 11 - http.Flusher 12 12 - })} 13 13 - } 14 14 - 15 15 - type writeFlusher struct { 16 16 - wf interface { 17 17 - io.Writer 18 18 - http.Flusher 19 19 - } 20 20 - } 21 21 - 22 22 - func (w writeFlusher) Write(p []byte) (int, error) { 23 23 - defer w.wf.Flush() 24 24 - return w.wf.Write(p) 25 25 - }

-66

git/tree.go

··· 1 1 - package git 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - 6 6 - "github.com/go-git/go-git/v5/plumbing/object" 7 7 - ) 8 8 - 9 9 - func (g *GitRepo) FileTree(path string) ([]NiceTree, error) { 10 10 - c, err := g.r.CommitObject(g.h) 11 11 - if err != nil { 12 12 - return nil, fmt.Errorf("commit object: %w", err) 13 13 - } 14 14 - 15 15 - files := []NiceTree{} 16 16 - tree, err := c.Tree() 17 17 - if err != nil { 18 18 - return nil, fmt.Errorf("file tree: %w", err) 19 19 - } 20 20 - 21 21 - if path == "" { 22 22 - files = makeNiceTree(tree) 23 23 - } else { 24 24 - o, err := tree.FindEntry(path) 25 25 - if err != nil { 26 26 - return nil, err 27 27 - } 28 28 - 29 29 - if !o.Mode.IsFile() { 30 30 - subtree, err := tree.Tree(path) 31 31 - if err != nil { 32 32 - return nil, err 33 33 - } 34 34 - 35 35 - files = makeNiceTree(subtree) 36 36 - } 37 37 - } 38 38 - 39 39 - return files, nil 40 40 - } 41 41 - 42 42 - // A nicer git tree representation. 43 43 - type NiceTree struct { 44 44 - Name string 45 45 - Mode string 46 46 - Size int64 47 47 - IsFile bool 48 48 - IsSubtree bool 49 49 - } 50 50 - 51 51 - func makeNiceTree(t *object.Tree) []NiceTree { 52 52 - nts := []NiceTree{} 53 53 - 54 54 - for _, e := range t.Entries { 55 55 - mode, _ := e.Mode.ToOSFileMode() 56 56 - sz, _ := t.Size(e.Name) 57 57 - nts = append(nts, NiceTree{ 58 58 - Name: e.Name, 59 59 - Mode: mode.String(), 60 60 - IsFile: e.Mode.IsFile(), 61 61 - Size: sz, 62 62 - }) 63 63 - } 64 64 - 65 65 - return nts 66 66 - }

+1 -1

knotserver/routes.go

··· 19 19 "github.com/go-chi/chi/v5" 20 20 "github.com/go-git/go-git/v5/plumbing" 21 21 "github.com/go-git/go-git/v5/plumbing/object" 22 22 - "github.com/icyphox/bild/db" 22 22 + "github.com/icyphox/bild/knotserver/db" 23 23 "github.com/icyphox/bild/knotserver/git" 24 24 "github.com/russross/blackfriday/v2" 25 25 )

-35

routes/access.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "github.com/go-chi/chi/v5" 5 5 - "github.com/icyphox/bild/auth" 6 6 - "github.com/icyphox/bild/db" 7 7 - "log" 8 8 - "net/http" 9 9 - ) 10 10 - 11 11 - func (h *Handle) AccessLevel(level db.Level) func(http.Handler) http.Handler { 12 12 - return func(next http.Handler) http.Handler { 13 13 - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 14 14 - repoOwnerHandle := chi.URLParam(r, "user") 15 15 - repoOwner, err := auth.ResolveIdent(r.Context(), repoOwnerHandle) 16 16 - if err != nil { 17 17 - log.Println("invalid did") 18 18 - http.Error(w, "invalid did", http.StatusNotFound) 19 19 - return 20 20 - } 21 21 - repoName := chi.URLParam(r, "name") 22 22 - session, _ := h.s.Get(r, "bild-session") 23 23 - did := session.Values["did"].(string) 24 24 - 25 25 - userLevel, err := h.db.GetAccessLevel(did, repoOwner.DID.String(), repoName) 26 26 - if err != nil || userLevel < level { 27 27 - log.Printf("unauthorized access: %s accessing %s/%s\n", did, repoOwnerHandle, repoName) 28 28 - log.Printf("wanted level: %s, got level %s", level.String(), userLevel.String()) 29 29 - http.Error(w, "Forbidden", http.StatusUnauthorized) 30 30 - return 31 31 - } 32 32 - next.ServeHTTP(w, r) 33 33 - }) 34 34 - } 35 35 - }

-72

routes/auth.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "log" 5 5 - "net/http" 6 6 - "time" 7 7 - 8 8 - comatproto "github.com/bluesky-social/indigo/api/atproto" 9 9 - "github.com/bluesky-social/indigo/xrpc" 10 10 - rauth "github.com/icyphox/bild/auth" 11 11 - ) 12 12 - 13 13 - const ( 14 14 - layout = "2006-01-02 15:04:05.999999999 -0700 MST" 15 15 - ) 16 16 - 17 17 - func (h *Handle) AuthMiddleware(next http.Handler) http.Handler { 18 18 - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 19 19 - session, _ := h.s.Get(r, "bild-session") 20 20 - auth, ok := session.Values["authenticated"].(bool) 21 21 - 22 22 - if !ok || !auth { 23 23 - log.Printf("not logged in, redirecting") 24 24 - http.Redirect(w, r, "/login", http.StatusTemporaryRedirect) 25 25 - return 26 26 - } 27 27 - 28 28 - // refresh if nearing expiry 29 29 - // TODO: dedup with /login 30 30 - expiryStr := session.Values["expiry"].(string) 31 31 - expiry, _ := time.Parse(layout, expiryStr) 32 32 - pdsUrl := session.Values["pds"].(string) 33 33 - did := session.Values["did"].(string) 34 34 - refreshJwt := session.Values["refreshJwt"].(string) 35 35 - 36 36 - if time.Now().After((expiry)) { 37 37 - log.Println("token expired, refreshing ...") 38 38 - 39 39 - client := xrpc.Client{ 40 40 - Host: pdsUrl, 41 41 - Auth: &xrpc.AuthInfo{ 42 42 - Did: did, 43 43 - AccessJwt: refreshJwt, 44 44 - RefreshJwt: refreshJwt, 45 45 - }, 46 46 - } 47 47 - atSession, err := comatproto.ServerRefreshSession(r.Context(), &client) 48 48 - if err != nil { 49 49 - log.Println(err) 50 50 - h.Write500(w) 51 51 - return 52 52 - } 53 53 - 54 54 - err = h.auth.StoreSession(r, w, nil, &rauth.AtSessionRefresh{ServerRefreshSession_Output: *atSession, PDSEndpoint: pdsUrl}) 55 55 - if err != nil { 56 56 - log.Printf("failed to store session for did: %s\n: %s", atSession.Did, err) 57 57 - h.Write500(w) 58 58 - return 59 59 - } 60 60 - 61 61 - log.Println("successfully refreshed token") 62 62 - } 63 63 - 64 64 - if r.URL.Path == "/login" { 65 65 - log.Println("already logged in") 66 66 - http.Redirect(w, r, "/", http.StatusTemporaryRedirect) 67 67 - return 68 68 - } 69 69 - 70 70 - next.ServeHTTP(w, r) 71 71 - }) 72 72 - }

-122

routes/file.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "bytes" 5 5 - "html/template" 6 6 - "io" 7 7 - "log" 8 8 - "net/http" 9 9 - "strings" 10 10 - 11 11 - "github.com/alecthomas/chroma/v2/formatters/html" 12 12 - "github.com/alecthomas/chroma/v2/lexers" 13 13 - "github.com/alecthomas/chroma/v2/styles" 14 14 - "github.com/icyphox/bild/git" 15 15 - ) 16 16 - 17 17 - func (h *Handle) listFiles(files []git.NiceTree, data map[string]any, w http.ResponseWriter) { 18 18 - data["files"] = files 19 19 - data["meta"] = h.c.Meta 20 20 - 21 21 - if err := h.t.ExecuteTemplate(w, "repo/tree", data); err != nil { 22 22 - log.Println(err) 23 23 - return 24 24 - } 25 25 - } 26 26 - 27 27 - func countLines(r io.Reader) (int, error) { 28 28 - buf := make([]byte, 32*1024) 29 29 - bufLen := 0 30 30 - count := 0 31 31 - nl := []byte{'\n'} 32 32 - 33 33 - for { 34 34 - c, err := r.Read(buf) 35 35 - if c > 0 { 36 36 - bufLen += c 37 37 - } 38 38 - count += bytes.Count(buf[:c], nl) 39 39 - 40 40 - switch { 41 41 - case err == io.EOF: 42 42 - /* handle last line not having a newline at the end */ 43 43 - if bufLen >= 1 && buf[(bufLen-1)%(32*1024)] != '\n' { 44 44 - count++ 45 45 - } 46 46 - return count, nil 47 47 - case err != nil: 48 48 - return 0, err 49 49 - } 50 50 - } 51 51 - } 52 52 - 53 53 - func (h *Handle) showFileWithHighlight(name, content string, data map[string]any, w http.ResponseWriter) { 54 54 - lexer := lexers.Get(name) 55 55 - if lexer == nil { 56 56 - lexer = lexers.Get(".txt") 57 57 - } 58 58 - 59 59 - style := styles.Get(h.c.Meta.SyntaxHighlight) 60 60 - if style == nil { 61 61 - style = styles.Get("monokailight") 62 62 - } 63 63 - 64 64 - formatter := html.New( 65 65 - html.WithLineNumbers(true), 66 66 - html.WithLinkableLineNumbers(true, "L"), 67 67 - ) 68 68 - 69 69 - iterator, err := lexer.Tokenise(nil, content) 70 70 - if err != nil { 71 71 - h.Write500(w) 72 72 - return 73 73 - } 74 74 - 75 75 - var code bytes.Buffer 76 76 - err = formatter.Format(&code, style, iterator) 77 77 - if err != nil { 78 78 - h.Write500(w) 79 79 - return 80 80 - } 81 81 - 82 82 - data["content"] = template.HTML(code.String()) 83 83 - data["meta"] = h.c.Meta 84 84 - data["chroma"] = true 85 85 - 86 86 - if err := h.t.ExecuteTemplate(w, "repo/file", data); err != nil { 87 87 - log.Println(err) 88 88 - return 89 89 - } 90 90 - } 91 91 - 92 92 - func (h *Handle) showFile(content string, data map[string]any, w http.ResponseWriter) { 93 93 - lc, err := countLines(strings.NewReader(content)) 94 94 - if err != nil { 95 95 - // Non-fatal, we'll just skip showing line numbers in the template. 96 96 - log.Printf("counting lines: %s", err) 97 97 - } 98 98 - 99 99 - lines := make([]int, lc) 100 100 - if lc > 0 { 101 101 - for i := range lines { 102 102 - lines[i] = i + 1 103 103 - } 104 104 - } 105 105 - 106 106 - data["linecount"] = lines 107 107 - data["content"] = content 108 108 - data["meta"] = h.c.Meta 109 109 - data["chroma"] = false 110 110 - 111 111 - if err := h.t.ExecuteTemplate(w, "repo/file", data); err != nil { 112 112 - log.Println(err) 113 113 - return 114 114 - } 115 115 - } 116 116 - 117 117 - func (h *Handle) showRaw(content string, w http.ResponseWriter) { 118 118 - w.WriteHeader(http.StatusOK) 119 119 - w.Header().Set("Content-Type", "text/plain") 120 120 - w.Write([]byte(content)) 121 121 - return 122 122 - }

-69

routes/git.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "compress/gzip" 5 5 - "io" 6 6 - "log" 7 7 - "net/http" 8 8 - "path/filepath" 9 9 - 10 10 - "github.com/icyphox/bild/git/service" 11 11 - ) 12 12 - 13 13 - func (d *Handle) InfoRefs(w http.ResponseWriter, r *http.Request) { 14 14 - name := displayRepoName(r) 15 15 - name = filepath.Clean(name) 16 16 - 17 17 - repo := filepath.Join(d.c.Repo.ScanPath, name) 18 18 - 19 19 - w.Header().Set("content-type", "application/x-git-upload-pack-advertisement") 20 20 - w.WriteHeader(http.StatusOK) 21 21 - 22 22 - cmd := service.ServiceCommand{ 23 23 - Dir: repo, 24 24 - Stdout: w, 25 25 - } 26 26 - 27 27 - if err := cmd.InfoRefs(); err != nil { 28 28 - http.Error(w, err.Error(), 500) 29 29 - log.Printf("git: failed to execute git-upload-pack (info/refs) %s", err) 30 30 - return 31 31 - } 32 32 - } 33 33 - 34 34 - func (d *Handle) UploadPack(w http.ResponseWriter, r *http.Request) { 35 35 - name := displayRepoName(r) 36 36 - name = filepath.Clean(name) 37 37 - 38 38 - repo := filepath.Join(d.c.Repo.ScanPath, name) 39 39 - 40 40 - w.Header().Set("content-type", "application/x-git-upload-pack-result") 41 41 - w.Header().Set("Connection", "Keep-Alive") 42 42 - w.Header().Set("Transfer-Encoding", "chunked") 43 43 - w.WriteHeader(http.StatusOK) 44 44 - 45 45 - cmd := service.ServiceCommand{ 46 46 - Dir: repo, 47 47 - Stdout: w, 48 48 - } 49 49 - 50 50 - var reader io.ReadCloser 51 51 - reader = r.Body 52 52 - 53 53 - if r.Header.Get("Content-Encoding") == "gzip" { 54 54 - reader, err := gzip.NewReader(r.Body) 55 55 - if err != nil { 56 56 - http.Error(w, err.Error(), 500) 57 57 - log.Printf("git: failed to create gzip reader: %s", err) 58 58 - return 59 59 - } 60 60 - defer reader.Close() 61 61 - } 62 62 - 63 63 - cmd.Stdin = reader 64 64 - if err := cmd.UploadPack(); err != nil { 65 65 - http.Error(w, err.Error(), 500) 66 66 - log.Printf("git: failed to execute git-upload-pack %s", err) 67 67 - return 68 68 - } 69 69 - }

-118

routes/handler.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "net/http" 6 6 - 7 7 - _ "github.com/bluesky-social/indigo/atproto/identity" 8 8 - _ "github.com/bluesky-social/indigo/atproto/syntax" 9 9 - _ "github.com/bluesky-social/indigo/xrpc" 10 10 - "github.com/go-chi/chi/v5" 11 11 - "github.com/gorilla/sessions" 12 12 - "github.com/icyphox/bild/auth" 13 13 - "github.com/icyphox/bild/config" 14 14 - database "github.com/icyphox/bild/db" 15 15 - "github.com/icyphox/bild/routes/middleware" 16 16 - "github.com/icyphox/bild/routes/tmpl" 17 17 - ) 18 18 - 19 19 - // Checks for gitprotocol-http(5) specific smells; if found, passes 20 20 - // the request on to the git http service, else render the web frontend. 21 21 - func (h *Handle) Multiplex(w http.ResponseWriter, r *http.Request) { 22 22 - path := chi.URLParam(r, "*") 23 23 - 24 24 - if r.URL.RawQuery == "service=git-receive-pack" { 25 25 - w.WriteHeader(http.StatusBadRequest) 26 26 - w.Write([]byte("no pushing allowed!")) 27 27 - return 28 28 - } 29 29 - 30 30 - if path == "info/refs" && 31 31 - r.URL.RawQuery == "service=git-upload-pack" && 32 32 - r.Method == "GET" { 33 33 - h.InfoRefs(w, r) 34 34 - } else if path == "git-upload-pack" && r.Method == "POST" { 35 35 - h.UploadPack(w, r) 36 36 - } else if r.Method == "GET" { 37 37 - h.RepoIndex(w, r) 38 38 - } 39 39 - } 40 40 - 41 41 - func Setup(c *config.Config, db *database.DB) (http.Handler, error) { 42 42 - r := chi.NewRouter() 43 43 - s := sessions.NewCookieStore([]byte("TODO_CHANGE_ME")) 44 44 - t, err := tmpl.Load(c.Dirs.Templates) 45 45 - if err != nil { 46 46 - return nil, fmt.Errorf("failed to load templates: %w", err) 47 47 - } 48 48 - 49 49 - auth := auth.NewAuth(s) 50 50 - 51 51 - h := Handle{ 52 52 - c: c, 53 53 - t: t, 54 54 - s: s, 55 55 - db: db, 56 56 - auth: auth, 57 57 - } 58 58 - 59 59 - r.Get("/", h.Timeline) 60 60 - 61 61 - r.Group(func(r chi.Router) { 62 62 - r.Get("/login", h.Login) 63 63 - r.Post("/login", h.Login) 64 64 - }) 65 65 - r.Get("/static/{file}", h.ServeStatic) 66 66 - 67 67 - r.Route("/repo", func(r chi.Router) { 68 68 - r.Use(h.AuthMiddleware) 69 69 - r.Get("/new", h.NewRepo) 70 70 - r.Put("/new", h.NewRepo) 71 71 - }) 72 72 - 73 73 - r.Group(func(r chi.Router) { 74 74 - r.Use(h.AuthMiddleware) 75 75 - r.Route("/settings", func(r chi.Router) { 76 76 - r.Get("/keys", h.Keys) 77 77 - r.Put("/keys", h.Keys) 78 78 - }) 79 79 - }) 80 80 - 81 81 - r.Route("/@{user}", func(r chi.Router) { 82 82 - r.Use(middleware.AddDID) 83 83 - r.Get("/", h.Index) 84 84 - 85 85 - // Repo routes 86 86 - r.Route("/{name}", func(r chi.Router) { 87 87 - r.Get("/", h.Multiplex) 88 88 - r.Post("/", h.Multiplex) 89 89 - 90 90 - r.Route("/tree/{ref}", func(r chi.Router) { 91 91 - r.Get("/*", h.RepoTree) 92 92 - }) 93 93 - 94 94 - r.Route("/blob/{ref}", func(r chi.Router) { 95 95 - r.Get("/*", h.FileContent) 96 96 - }) 97 97 - 98 98 - r.Get("/log/{ref}", h.Log) 99 99 - r.Get("/archive/{file}", h.Archive) 100 100 - r.Get("/commit/{ref}", h.Diff) 101 101 - r.Get("/refs/", h.Refs) 102 102 - 103 103 - r.Group(func(r chi.Router) { 104 104 - // settings page is only accessible to owners 105 105 - r.Use(h.AccessLevel(database.Owner)) 106 106 - r.Route("/settings", func(r chi.Router) { 107 107 - r.Put("/collaborators", h.Collaborators) 108 108 - }) 109 109 - }) 110 110 - 111 111 - // Catch-all routes 112 112 - r.Get("/*", h.Multiplex) 113 113 - r.Post("/*", h.Multiplex) 114 114 - }) 115 115 - }) 116 116 - 117 117 - return r, nil 118 118 - }

-29

routes/html_util.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "log" 6 6 - "net/http" 7 7 - ) 8 8 - 9 9 - func (h *Handle) Write404(w http.ResponseWriter) { 10 10 - w.WriteHeader(404) 11 11 - if err := h.t.ExecuteTemplate(w, "errors/404", nil); err != nil { 12 12 - log.Printf("404 template: %s", err) 13 13 - } 14 14 - } 15 15 - 16 16 - func (h *Handle) Write500(w http.ResponseWriter) { 17 17 - w.WriteHeader(500) 18 18 - if err := h.t.ExecuteTemplate(w, "errors/500", nil); err != nil { 19 19 - log.Printf("500 template: %s", err) 20 20 - } 21 21 - } 22 22 - 23 23 - func (h *Handle) WriteOOBNotice(w http.ResponseWriter, id, msg string) { 24 24 - html := fmt.Sprintf(`<span id="%s" hx-swap-oob="innerHTML">%s</span>`, id, msg) 25 25 - 26 26 - w.Header().Set("Content-Type", "text/html") 27 27 - w.WriteHeader(http.StatusOK) 28 28 - w.Write([]byte(html)) 29 29 - }

-62

routes/internal.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "encoding/json" 5 5 - "net/http" 6 6 - 7 7 - "github.com/go-chi/chi/v5" 8 8 - "github.com/icyphox/bild/config" 9 9 - "github.com/icyphox/bild/db" 10 10 - ) 11 11 - 12 12 - type InternalHandle struct { 13 13 - c *config.Config 14 14 - db *db.DB 15 15 - } 16 16 - 17 17 - func SetupInternal(c *config.Config, db *db.DB) http.Handler { 18 18 - ih := &InternalHandle{ 19 19 - c: c, 20 20 - db: db, 21 21 - } 22 22 - 23 23 - r := chi.NewRouter() 24 24 - r.Route("/internal/allkeys", func(r chi.Router) { 25 25 - r.Get("/", ih.AllKeys) 26 26 - }) 27 27 - 28 28 - return r 29 29 - } 30 30 - 31 31 - func (h *InternalHandle) returnJSON(w http.ResponseWriter, data interface{}) error { 32 32 - w.Header().Set("Content-Type", "application/json") 33 33 - res, err := json.Marshal(data) 34 34 - if err != nil { 35 35 - return err 36 36 - } 37 37 - _, err = w.Write(res) 38 38 - return err 39 39 - } 40 40 - 41 41 - func (h *InternalHandle) returnErr(w http.ResponseWriter, err error) error { 42 42 - w.WriteHeader(http.StatusInternalServerError) 43 43 - return h.returnJSON(w, map[string]string{ 44 44 - "error": err.Error(), 45 45 - }) 46 46 - } 47 47 - 48 48 - func (h *InternalHandle) AllKeys(w http.ResponseWriter, r *http.Request) { 49 49 - keys, err := h.db.GetAllPublicKeys() 50 50 - if err != nil { 51 51 - h.returnErr(w, err) 52 52 - return 53 53 - } 54 54 - keyMap := map[string]string{} 55 55 - for _, key := range keys { 56 56 - keyMap[key.DID] = key.Key 57 57 - } 58 58 - if err := h.returnJSON(w, keyMap); err != nil { 59 59 - h.returnErr(w, err) 60 60 - return 61 61 - } 62 62 - }

-61

routes/middleware/did.go

··· 1 1 - package middleware 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "log" 6 6 - "net/http" 7 7 - "sync" 8 8 - "time" 9 9 - 10 10 - "github.com/bluesky-social/indigo/atproto/identity" 11 11 - "github.com/icyphox/bild/auth" 12 12 - ) 13 13 - 14 14 - type cachedIdent struct { 15 15 - ident *identity.Identity 16 16 - expiry time.Time 17 17 - } 18 18 - 19 19 - var ( 20 20 - identCache = make(map[string]cachedIdent) 21 21 - cacheMutex sync.RWMutex 22 22 - ) 23 23 - 24 24 - // Only use this middleware for routes that require a handle 25 25 - // /@{user}/... 26 26 - func AddDID(next http.Handler) http.Handler { 27 27 - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 28 28 - user := r.PathValue("user") 29 29 - 30 30 - // Check cache first 31 31 - cacheMutex.RLock() 32 32 - if cached, ok := identCache[user]; ok && time.Now().Before(cached.expiry) { 33 33 - cacheMutex.RUnlock() 34 34 - ctx := context.WithValue(r.Context(), "did", cached.ident.DID.String()) 35 35 - r = r.WithContext(ctx) 36 36 - next.ServeHTTP(w, r) 37 37 - return 38 38 - } 39 39 - cacheMutex.RUnlock() 40 40 - 41 41 - // Cache miss - resolve and cache 42 42 - ident, err := auth.ResolveIdent(r.Context(), user) 43 43 - if err != nil { 44 44 - log.Println("error resolving identity", err) 45 45 - http.Error(w, "error resolving identity", http.StatusNotFound) 46 46 - return 47 47 - } 48 48 - 49 49 - cacheMutex.Lock() 50 50 - identCache[user] = cachedIdent{ 51 51 - ident: ident, 52 52 - expiry: time.Now().Add(24 * time.Hour), 53 53 - } 54 54 - cacheMutex.Unlock() 55 55 - 56 56 - ctx := context.WithValue(r.Context(), "did", ident.DID.String()) 57 57 - r = r.WithContext(ctx) 58 58 - 59 59 - next.ServeHTTP(w, r) 60 60 - }) 61 61 - }

-643

routes/routes.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "compress/gzip" 5 5 - "errors" 6 6 - "fmt" 7 7 - "html/template" 8 8 - "log" 9 9 - "net/http" 10 10 - "os" 11 11 - "path/filepath" 12 12 - "sort" 13 13 - "strconv" 14 14 - "strings" 15 15 - "time" 16 16 - 17 17 - comatproto "github.com/bluesky-social/indigo/api/atproto" 18 18 - lexutil "github.com/bluesky-social/indigo/lex/util" 19 19 - "github.com/dustin/go-humanize" 20 20 - "github.com/go-chi/chi/v5" 21 21 - "github.com/go-git/go-git/v5/plumbing" 22 22 - "github.com/google/uuid" 23 23 - "github.com/gorilla/sessions" 24 24 - shbild "github.com/icyphox/bild/api/bild" 25 25 - "github.com/icyphox/bild/auth" 26 26 - "github.com/icyphox/bild/config" 27 27 - "github.com/icyphox/bild/db" 28 28 - "github.com/icyphox/bild/git" 29 29 - "github.com/russross/blackfriday/v2" 30 30 - "golang.org/x/crypto/ssh" 31 31 - ) 32 32 - 33 33 - type Handle struct { 34 34 - c *config.Config 35 35 - t *template.Template 36 36 - s *sessions.CookieStore 37 37 - db *db.DB 38 38 - auth *auth.Auth 39 39 - } 40 40 - 41 41 - func (h *Handle) Index(w http.ResponseWriter, r *http.Request) { 42 42 - name := displayRepoName(r) 43 43 - path := filepath.Join(h.c.Repo.ScanPath, name) 44 44 - dirs, err := os.ReadDir(path) 45 45 - if err != nil { 46 46 - h.Write500(w) 47 47 - log.Printf("reading scan path: %s", err) 48 48 - return 49 49 - } 50 50 - 51 51 - type info struct { 52 52 - DisplayName, Name, Desc, Idle string 53 53 - d time.Time 54 54 - } 55 55 - 56 56 - infos := []info{} 57 57 - 58 58 - for _, dir := range dirs { 59 59 - name := dir.Name() 60 60 - if !dir.IsDir() || h.isIgnored(name) || h.isUnlisted(name) { 61 61 - continue 62 62 - } 63 63 - 64 64 - gr, err := git.Open(path, "") 65 65 - if err != nil { 66 66 - log.Println(err) 67 67 - continue 68 68 - } 69 69 - 70 70 - c, err := gr.LastCommit() 71 71 - if err != nil { 72 72 - h.Write500(w) 73 73 - log.Println(err) 74 74 - return 75 75 - } 76 76 - 77 77 - infos = append(infos, info{ 78 78 - DisplayName: trimDotGit(name), 79 79 - Name: name, 80 80 - Desc: getDescription(path), 81 81 - Idle: humanize.Time(c.Author.When), 82 82 - d: c.Author.When, 83 83 - }) 84 84 - } 85 85 - 86 86 - sort.Slice(infos, func(i, j int) bool { 87 87 - return infos[j].d.Before(infos[i].d) 88 88 - }) 89 89 - 90 90 - data := make(map[string]interface{}) 91 91 - data["meta"] = h.c.Meta 92 92 - data["info"] = infos 93 93 - 94 94 - if err := h.t.ExecuteTemplate(w, "index", data); err != nil { 95 95 - log.Println(err) 96 96 - return 97 97 - } 98 98 - } 99 99 - 100 100 - func (h *Handle) RepoIndex(w http.ResponseWriter, r *http.Request) { 101 101 - name := displayRepoName(r) 102 102 - if h.isIgnored(name) { 103 103 - h.Write404(w) 104 104 - return 105 105 - } 106 106 - 107 107 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 108 108 - 109 109 - gr, err := git.Open(path, "") 110 110 - if err != nil { 111 111 - if errors.Is(err, plumbing.ErrReferenceNotFound) { 112 112 - h.t.ExecuteTemplate(w, "repo/empty", nil) 113 113 - return 114 114 - } else { 115 115 - h.Write404(w) 116 116 - return 117 117 - } 118 118 - } 119 119 - commits, err := gr.Commits() 120 120 - if err != nil { 121 121 - h.Write500(w) 122 122 - log.Println(err) 123 123 - return 124 124 - } 125 125 - 126 126 - var readmeContent template.HTML 127 127 - for _, readme := range h.c.Repo.Readme { 128 128 - ext := filepath.Ext(readme) 129 129 - content, _ := gr.FileContent(readme) 130 130 - if len(content) > 0 { 131 131 - switch ext { 132 132 - case ".md", ".mkd", ".markdown": 133 133 - unsafe := blackfriday.Run( 134 134 - []byte(content), 135 135 - blackfriday.WithExtensions(blackfriday.CommonExtensions), 136 136 - ) 137 137 - html := sanitize(unsafe) 138 138 - readmeContent = template.HTML(html) 139 139 - default: 140 140 - safe := sanitize([]byte(content)) 141 141 - readmeContent = template.HTML( 142 142 - fmt.Sprintf(`<pre>%s</pre>`, safe), 143 143 - ) 144 144 - } 145 145 - break 146 146 - } 147 147 - } 148 148 - 149 149 - if readmeContent == "" { 150 150 - log.Printf("no readme found for %s", name) 151 151 - } 152 152 - 153 153 - mainBranch, err := gr.FindMainBranch(h.c.Repo.MainBranch) 154 154 - if err != nil { 155 155 - h.Write500(w) 156 156 - log.Println(err) 157 157 - return 158 158 - } 159 159 - 160 160 - if len(commits) >= 3 { 161 161 - commits = commits[:3] 162 162 - } 163 163 - 164 164 - data := make(map[string]any) 165 165 - data["name"] = name 166 166 - data["displayname"] = trimDotGit(name) 167 167 - data["ref"] = mainBranch 168 168 - data["readme"] = readmeContent 169 169 - data["commits"] = commits 170 170 - data["desc"] = getDescription(path) 171 171 - data["servername"] = h.c.Server.Name 172 172 - data["meta"] = h.c.Meta 173 173 - data["gomod"] = isGoModule(gr) 174 174 - 175 175 - if err := h.t.ExecuteTemplate(w, "repo/repo", data); err != nil { 176 176 - log.Println(err) 177 177 - return 178 178 - } 179 179 - 180 180 - return 181 181 - } 182 182 - 183 183 - func (h *Handle) RepoTree(w http.ResponseWriter, r *http.Request) { 184 184 - name := displayRepoName(r) 185 185 - if h.isIgnored(name) { 186 186 - h.Write404(w) 187 187 - return 188 188 - } 189 189 - treePath := chi.URLParam(r, "*") 190 190 - ref := chi.URLParam(r, "ref") 191 191 - 192 192 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 193 193 - gr, err := git.Open(path, ref) 194 194 - if err != nil { 195 195 - h.Write404(w) 196 196 - return 197 197 - } 198 198 - 199 199 - files, err := gr.FileTree(treePath) 200 200 - if err != nil { 201 201 - h.Write500(w) 202 202 - log.Println(err) 203 203 - return 204 204 - } 205 205 - 206 206 - data := make(map[string]any) 207 207 - data["name"] = name 208 208 - data["displayname"] = trimDotGit(name) 209 209 - data["ref"] = ref 210 210 - data["parent"] = treePath 211 211 - data["desc"] = getDescription(path) 212 212 - data["dotdot"] = filepath.Dir(treePath) 213 213 - 214 214 - h.listFiles(files, data, w) 215 215 - return 216 216 - } 217 217 - 218 218 - func (h *Handle) FileContent(w http.ResponseWriter, r *http.Request) { 219 219 - var raw bool 220 220 - if rawParam, err := strconv.ParseBool(r.URL.Query().Get("raw")); err == nil { 221 221 - raw = rawParam 222 222 - } 223 223 - 224 224 - name := displayRepoName(r) 225 225 - 226 226 - if h.isIgnored(name) { 227 227 - h.Write404(w) 228 228 - return 229 229 - } 230 230 - treePath := chi.URLParam(r, "*") 231 231 - ref := chi.URLParam(r, "ref") 232 232 - 233 233 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 234 234 - gr, err := git.Open(path, ref) 235 235 - if err != nil { 236 236 - h.Write404(w) 237 237 - return 238 238 - } 239 239 - 240 240 - contents, err := gr.FileContent(treePath) 241 241 - if err != nil { 242 242 - h.Write500(w) 243 243 - return 244 244 - } 245 245 - data := make(map[string]any) 246 246 - data["name"] = name 247 247 - data["displayname"] = trimDotGit(name) 248 248 - data["ref"] = ref 249 249 - data["desc"] = getDescription(path) 250 250 - data["path"] = treePath 251 251 - 252 252 - safe := sanitize([]byte(contents)) 253 253 - 254 254 - if raw { 255 255 - h.showRaw(string(safe), w) 256 256 - } else { 257 257 - if h.c.Meta.SyntaxHighlight == "" { 258 258 - h.showFile(string(safe), data, w) 259 259 - } else { 260 260 - h.showFileWithHighlight(treePath, string(safe), data, w) 261 261 - } 262 262 - } 263 263 - } 264 264 - 265 265 - func (h *Handle) Archive(w http.ResponseWriter, r *http.Request) { 266 266 - name := displayRepoName(r) 267 267 - if h.isIgnored(name) { 268 268 - h.Write404(w) 269 269 - return 270 270 - } 271 271 - 272 272 - file := chi.URLParam(r, "file") 273 273 - 274 274 - // TODO: extend this to add more files compression (e.g.: xz) 275 275 - if !strings.HasSuffix(file, ".tar.gz") { 276 276 - h.Write404(w) 277 277 - return 278 278 - } 279 279 - 280 280 - ref := strings.TrimSuffix(file, ".tar.gz") 281 281 - 282 282 - // This allows the browser to use a proper name for the file when 283 283 - // downloading 284 284 - filename := fmt.Sprintf("%s-%s.tar.gz", name, ref) 285 285 - setContentDisposition(w, filename) 286 286 - setGZipMIME(w) 287 287 - 288 288 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 289 289 - gr, err := git.Open(path, ref) 290 290 - if err != nil { 291 291 - h.Write404(w) 292 292 - return 293 293 - } 294 294 - 295 295 - gw := gzip.NewWriter(w) 296 296 - defer gw.Close() 297 297 - 298 298 - prefix := fmt.Sprintf("%s-%s", name, ref) 299 299 - err = gr.WriteTar(gw, prefix) 300 300 - if err != nil { 301 301 - // once we start writing to the body we can't report error anymore 302 302 - // so we are only left with printing the error. 303 303 - log.Println(err) 304 304 - return 305 305 - } 306 306 - 307 307 - err = gw.Flush() 308 308 - if err != nil { 309 309 - // once we start writing to the body we can't report error anymore 310 310 - // so we are only left with printing the error. 311 311 - log.Println(err) 312 312 - return 313 313 - } 314 314 - } 315 315 - 316 316 - func (h *Handle) Log(w http.ResponseWriter, r *http.Request) { 317 317 - name := displayRepoName(r) 318 318 - if h.isIgnored(name) { 319 319 - h.Write404(w) 320 320 - return 321 321 - } 322 322 - ref := chi.URLParam(r, "ref") 323 323 - 324 324 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 325 325 - gr, err := git.Open(path, ref) 326 326 - if err != nil { 327 327 - h.Write404(w) 328 328 - return 329 329 - } 330 330 - 331 331 - commits, err := gr.Commits() 332 332 - if err != nil { 333 333 - h.Write500(w) 334 334 - log.Println(err) 335 335 - return 336 336 - } 337 337 - 338 338 - data := make(map[string]interface{}) 339 339 - data["commits"] = commits 340 340 - data["meta"] = h.c.Meta 341 341 - data["name"] = name 342 342 - data["displayname"] = trimDotGit(name) 343 343 - data["ref"] = ref 344 344 - data["desc"] = getDescription(path) 345 345 - data["log"] = true 346 346 - 347 347 - if err := h.t.ExecuteTemplate(w, "repo/log", data); err != nil { 348 348 - log.Println(err) 349 349 - return 350 350 - } 351 351 - } 352 352 - 353 353 - func (h *Handle) Diff(w http.ResponseWriter, r *http.Request) { 354 354 - name := displayRepoName(r) 355 355 - if h.isIgnored(name) { 356 356 - h.Write404(w) 357 357 - return 358 358 - } 359 359 - ref := chi.URLParam(r, "ref") 360 360 - 361 361 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 362 362 - gr, err := git.Open(path, ref) 363 363 - if err != nil { 364 364 - h.Write404(w) 365 365 - return 366 366 - } 367 367 - 368 368 - diff, err := gr.Diff() 369 369 - if err != nil { 370 370 - h.Write500(w) 371 371 - log.Println(err) 372 372 - return 373 373 - } 374 374 - 375 375 - data := make(map[string]interface{}) 376 376 - 377 377 - data["commit"] = diff.Commit 378 378 - data["stat"] = diff.Stat 379 379 - data["diff"] = diff.Diff 380 380 - data["meta"] = h.c.Meta 381 381 - data["name"] = name 382 382 - data["displayname"] = trimDotGit(name) 383 383 - data["ref"] = ref 384 384 - data["desc"] = getDescription(path) 385 385 - 386 386 - if err := h.t.ExecuteTemplate(w, "repo/commit", data); err != nil { 387 387 - log.Println(err) 388 388 - return 389 389 - } 390 390 - } 391 391 - 392 392 - func (h *Handle) Refs(w http.ResponseWriter, r *http.Request) { 393 393 - name := chi.URLParam(r, "name") 394 394 - if h.isIgnored(name) { 395 395 - h.Write404(w) 396 396 - return 397 397 - } 398 398 - 399 399 - path := filepath.Join(h.c.Repo.ScanPath, didPath(r)) 400 400 - gr, err := git.Open(path, "") 401 401 - if err != nil { 402 402 - h.Write404(w) 403 403 - return 404 404 - } 405 405 - 406 406 - tags, err := gr.Tags() 407 407 - if err != nil { 408 408 - // Non-fatal, we *should* have at least one branch to show. 409 409 - log.Println(err) 410 410 - } 411 411 - 412 412 - branches, err := gr.Branches() 413 413 - if err != nil { 414 414 - log.Println(err) 415 415 - h.Write500(w) 416 416 - return 417 417 - } 418 418 - 419 419 - data := make(map[string]interface{}) 420 420 - 421 421 - data["meta"] = h.c.Meta 422 422 - data["name"] = name 423 423 - data["displayname"] = trimDotGit(name) 424 424 - data["branches"] = branches 425 425 - data["tags"] = tags 426 426 - data["desc"] = getDescription(path) 427 427 - 428 428 - if err := h.t.ExecuteTemplate(w, "repo/refs", data); err != nil { 429 429 - log.Println(err) 430 430 - return 431 431 - } 432 432 - } 433 433 - 434 434 - func (h *Handle) Collaborators(w http.ResponseWriter, r *http.Request) { 435 435 - // put repo resolution in middleware 436 436 - repoOwnerHandle := chi.URLParam(r, "user") 437 437 - repoOwner, err := auth.ResolveIdent(r.Context(), repoOwnerHandle) 438 438 - if err != nil { 439 439 - log.Println("invalid did") 440 440 - http.Error(w, "invalid did", http.StatusNotFound) 441 441 - return 442 442 - } 443 443 - repoName := chi.URLParam(r, "name") 444 444 - 445 445 - switch r.Method { 446 446 - case http.MethodGet: 447 447 - // TODO fetch a list of collaborators and their access rights 448 448 - http.Error(w, "unimpl 1", http.StatusInternalServerError) 449 449 - return 450 450 - case http.MethodPut: 451 451 - newUser := r.FormValue("newUser") 452 452 - if newUser == "" { 453 453 - // TODO: htmx this 454 454 - http.Error(w, "unimpl 2", http.StatusInternalServerError) 455 455 - return 456 456 - } 457 457 - newUserIdentity, err := auth.ResolveIdent(r.Context(), newUser) 458 458 - if err != nil { 459 459 - // TODO: htmx this 460 460 - log.Println("invalid handle") 461 461 - http.Error(w, "unimpl 3", http.StatusBadRequest) 462 462 - return 463 463 - } 464 464 - err = h.db.SetWriter(newUserIdentity.DID.String(), repoOwner.DID.String(), repoName) 465 465 - if err != nil { 466 466 - // TODO: htmx this 467 467 - log.Println("failed to add collaborator") 468 468 - http.Error(w, "unimpl 4", http.StatusInternalServerError) 469 469 - return 470 470 - } 471 471 - 472 472 - log.Println("success") 473 473 - return 474 474 - 475 475 - } 476 476 - } 477 477 - 478 478 - func (h *Handle) ServeStatic(w http.ResponseWriter, r *http.Request) { 479 479 - f := chi.URLParam(r, "file") 480 480 - f = filepath.Clean(filepath.Join(h.c.Dirs.Static, f)) 481 481 - 482 482 - http.ServeFile(w, r, f) 483 483 - } 484 484 - 485 485 - func (h *Handle) Login(w http.ResponseWriter, r *http.Request) { 486 486 - switch r.Method { 487 487 - case http.MethodGet: 488 488 - if err := h.t.ExecuteTemplate(w, "user/login", nil); err != nil { 489 489 - log.Println(err) 490 490 - return 491 491 - } 492 492 - case http.MethodPost: 493 493 - username := r.FormValue("username") 494 494 - appPassword := r.FormValue("app_password") 495 495 - 496 496 - atSession, err := h.auth.CreateInitialSession(w, r, username, appPassword) 497 497 - if err != nil { 498 498 - h.WriteOOBNotice(w, "login", "Invalid username or app password.") 499 499 - log.Printf("creating initial session: %s", err) 500 500 - return 501 501 - } 502 502 - 503 503 - err = h.auth.StoreSession(r, w, &atSession, nil) 504 504 - if err != nil { 505 505 - h.WriteOOBNotice(w, "login", "Failed to store session.") 506 506 - log.Printf("storing session: %s", err) 507 507 - return 508 508 - } 509 509 - 510 510 - log.Printf("successfully saved session for %s (%s)", atSession.Handle, atSession.Did) 511 511 - http.Redirect(w, r, "/", http.StatusSeeOther) 512 512 - return 513 513 - } 514 514 - } 515 515 - 516 516 - func (h *Handle) Keys(w http.ResponseWriter, r *http.Request) { 517 517 - session, _ := h.s.Get(r, "bild-session") 518 518 - did := session.Values["did"].(string) 519 519 - 520 520 - switch r.Method { 521 521 - case http.MethodGet: 522 522 - keys, err := h.db.GetPublicKeys(did) 523 523 - if err != nil { 524 524 - h.WriteOOBNotice(w, "keys", "Failed to list keys. Try again later.") 525 525 - log.Println(err) 526 526 - return 527 527 - } 528 528 - 529 529 - data := make(map[string]interface{}) 530 530 - data["keys"] = keys 531 531 - if err := h.t.ExecuteTemplate(w, "settings/keys", data); err != nil { 532 532 - log.Println(err) 533 533 - return 534 534 - } 535 535 - case http.MethodPut: 536 536 - key := r.FormValue("key") 537 537 - name := r.FormValue("name") 538 538 - client, _ := h.auth.AuthorizedClient(r) 539 539 - 540 540 - _, _, _, _, err := ssh.ParseAuthorizedKey([]byte(key)) 541 541 - if err != nil { 542 542 - h.WriteOOBNotice(w, "keys", "Invalid public key. Check your formatting and try again.") 543 543 - log.Printf("parsing public key: %s", err) 544 544 - return 545 545 - } 546 546 - 547 547 - if err := h.db.AddPublicKey(did, name, key); err != nil { 548 548 - h.WriteOOBNotice(w, "keys", "Failed to add key.") 549 549 - log.Printf("adding public key: %s", err) 550 550 - return 551 551 - } 552 552 - 553 553 - // store in pds too 554 554 - resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 555 555 - Collection: "sh.bild.publicKey", 556 556 - Repo: did, 557 557 - Rkey: uuid.New().String(), 558 558 - Record: &lexutil.LexiconTypeDecoder{Val: &shbild.PublicKey{ 559 559 - Created: time.Now().String(), 560 560 - Key: key, 561 561 - Name: name, 562 562 - }}, 563 563 - }) 564 564 - 565 565 - // invalid record 566 566 - if err != nil { 567 567 - h.WriteOOBNotice(w, "keys", "Invalid inputs. Check your formatting and try again.") 568 568 - log.Printf("failed to create record: %s", err) 569 569 - return 570 570 - } 571 571 - 572 572 - log.Println("created atproto record: ", resp.Uri) 573 573 - 574 574 - h.WriteOOBNotice(w, "keys", "Key added!") 575 575 - return 576 576 - } 577 577 - } 578 578 - 579 579 - func (h *Handle) NewRepo(w http.ResponseWriter, r *http.Request) { 580 580 - session, _ := h.s.Get(r, "bild-session") 581 581 - did := session.Values["did"].(string) 582 582 - handle := session.Values["handle"].(string) 583 583 - 584 584 - switch r.Method { 585 585 - case http.MethodGet: 586 586 - if err := h.t.ExecuteTemplate(w, "repo/new", nil); err != nil { 587 587 - log.Println(err) 588 588 - return 589 589 - } 590 590 - case http.MethodPut: 591 591 - name := r.FormValue("name") 592 592 - description := r.FormValue("description") 593 593 - 594 594 - repoPath := filepath.Join(h.c.Repo.ScanPath, did, name) 595 595 - err := git.InitBare(repoPath) 596 596 - if err != nil { 597 597 - h.WriteOOBNotice(w, "repo", "Error creating repo. Try again later.") 598 598 - return 599 599 - } 600 600 - 601 601 - // For use by repoguard 602 602 - didPath := filepath.Join(repoPath, "did") 603 603 - err = os.WriteFile(didPath, []byte(did), 0644) 604 604 - if err != nil { 605 605 - h.WriteOOBNotice(w, "repo", "Error creating repo. Try again later.") 606 606 - return 607 607 - } 608 608 - 609 609 - // TODO: add repo & setting-to-owner must happen in the same transaction 610 610 - err = h.db.AddRepo(did, name, description) 611 611 - if err != nil { 612 612 - log.Println(err) 613 613 - h.WriteOOBNotice(w, "repo", "Error creating repo. Try again later.") 614 614 - return 615 615 - } 616 616 - // current user is set to owner of did/name repo 617 617 - err = h.db.SetOwner(did, did, name) 618 618 - if err != nil { 619 619 - log.Println(err) 620 620 - h.WriteOOBNotice(w, "repo", "Error creating repo. Try again later.") 621 621 - return 622 622 - } 623 623 - 624 624 - w.Header().Set("HX-Redirect", fmt.Sprintf("/@%s/%s", handle, name)) 625 625 - w.WriteHeader(http.StatusOK) 626 626 - } 627 627 - } 628 628 - 629 629 - func (h *Handle) Timeline(w http.ResponseWriter, r *http.Request) { 630 630 - session, err := h.s.Get(r, "bild-session") 631 631 - user := make(map[string]string) 632 632 - if err != nil || session.IsNew { 633 633 - // user is not logged in 634 634 - } else { 635 635 - user["handle"] = session.Values["handle"].(string) 636 636 - user["did"] = session.Values["did"].(string) 637 637 - } 638 638 - 639 639 - if err := h.t.ExecuteTemplate(w, "timeline", user); err != nil { 640 640 - log.Println(err) 641 641 - return 642 642 - } 643 643 - }

-54

routes/tmpl/tmpl.go

··· 1 1 - package tmpl 2 2 - 3 3 - import ( 4 4 - "html/template" 5 5 - "log" 6 6 - "os" 7 7 - "path/filepath" 8 8 - "strings" 9 9 - ) 10 10 - 11 11 - func Load(tpath string) (*template.Template, error) { 12 12 - tmpl := template.New("") 13 13 - loadedTemplates := make(map[string]bool) 14 14 - 15 15 - err := filepath.Walk(tpath, func(path string, info os.FileInfo, err error) error { 16 16 - if err != nil { 17 17 - return err 18 18 - } 19 19 - 20 20 - if !info.IsDir() && strings.HasSuffix(path, ".html") { 21 21 - content, err := os.ReadFile(path) 22 22 - if err != nil { 23 23 - return err 24 24 - } 25 25 - 26 26 - relPath, err := filepath.Rel(tpath, path) 27 27 - if err != nil { 28 28 - return err 29 29 - } 30 30 - 31 31 - name := strings.TrimSuffix(relPath, ".html") 32 32 - name = strings.ReplaceAll(name, string(filepath.Separator), "/") 33 33 - 34 34 - _, err = tmpl.New(name).Parse(string(content)) 35 35 - if err != nil { 36 36 - log.Printf("error parsing template %s: %v", name, err) 37 37 - return err 38 38 - } 39 39 - 40 40 - loadedTemplates[name] = true 41 41 - log.Printf("loaded template: %s", name) 42 42 - return err 43 43 - } 44 44 - return nil 45 45 - }) 46 46 - 47 47 - if err != nil { 48 48 - return nil, err 49 49 - } 50 50 - 51 51 - log.Printf("total templates loaded: %d", len(loadedTemplates)) 52 52 - return tmpl, nil 53 53 - 54 54 - }

-146

routes/util.go

··· 1 1 - package routes 2 2 - 3 3 - import ( 4 4 - "fmt" 5 5 - "io/fs" 6 6 - "log" 7 7 - "net/http" 8 8 - "os" 9 9 - "path/filepath" 10 10 - "strings" 11 11 - 12 12 - "github.com/go-chi/chi/v5" 13 13 - "github.com/icyphox/bild/auth" 14 14 - "github.com/icyphox/bild/git" 15 15 - "github.com/microcosm-cc/bluemonday" 16 16 - ) 17 17 - 18 18 - func sanitize(content []byte) []byte { 19 19 - return bluemonday.UGCPolicy().SanitizeBytes([]byte(content)) 20 20 - } 21 21 - 22 22 - func isGoModule(gr *git.GitRepo) bool { 23 23 - _, err := gr.FileContent("go.mod") 24 24 - return err == nil 25 25 - } 26 26 - 27 27 - func displayRepoName(r *http.Request) string { 28 28 - user := r.Context().Value("did").(string) 29 29 - name := chi.URLParam(r, "name") 30 30 - 31 31 - handle, err := auth.ResolveIdent(r.Context(), user) 32 32 - if err != nil { 33 33 - log.Printf("failed to resolve ident: %s: %s", user, err) 34 34 - return fmt.Sprintf("%s/%s", user, name) 35 35 - } 36 36 - 37 37 - return fmt.Sprintf("@%s/%s", handle.Handle.String(), name) 38 38 - } 39 39 - 40 40 - func didPath(r *http.Request) string { 41 41 - did := r.Context().Value("did").(string) 42 42 - path := filepath.Join(did, chi.URLParam(r, "name")) 43 43 - filepath.Clean(path) 44 44 - return path 45 45 - } 46 46 - 47 47 - func trimDotGit(name string) string { 48 48 - return strings.TrimSuffix(name, ".git") 49 49 - } 50 50 - 51 51 - func getDescription(path string) (desc string) { 52 52 - db, err := os.ReadFile(filepath.Join(path, "description")) 53 53 - if err == nil { 54 54 - desc = string(db) 55 55 - } else { 56 56 - desc = "" 57 57 - } 58 58 - return 59 59 - } 60 60 - 61 61 - func (h *Handle) isUnlisted(name string) bool { 62 62 - for _, i := range h.c.Repo.Unlisted { 63 63 - if name == i { 64 64 - return true 65 65 - } 66 66 - } 67 67 - 68 68 - return false 69 69 - } 70 70 - 71 71 - func (h *Handle) isIgnored(name string) bool { 72 72 - for _, i := range h.c.Repo.Ignore { 73 73 - if name == i { 74 74 - return true 75 75 - } 76 76 - } 77 77 - 78 78 - return false 79 79 - } 80 80 - 81 81 - type repoInfo struct { 82 82 - Git *git.GitRepo 83 83 - Path string 84 84 - Category string 85 85 - } 86 86 - 87 87 - func (d *Handle) getAllRepos() ([]repoInfo, error) { 88 88 - repos := []repoInfo{} 89 89 - max := strings.Count(d.c.Repo.ScanPath, string(os.PathSeparator)) + 2 90 90 - 91 91 - err := filepath.WalkDir(d.c.Repo.ScanPath, func(path string, de fs.DirEntry, err error) error { 92 92 - if err != nil { 93 93 - return err 94 94 - } 95 95 - 96 96 - if de.IsDir() { 97 97 - // Check if we've exceeded our recursion depth 98 98 - if strings.Count(path, string(os.PathSeparator)) > max { 99 99 - return fs.SkipDir 100 100 - } 101 101 - 102 102 - if d.isIgnored(path) { 103 103 - return fs.SkipDir 104 104 - } 105 105 - 106 106 - // A bare repo should always have at least a HEAD file, if it 107 107 - // doesn't we can continue recursing 108 108 - if _, err := os.Lstat(filepath.Join(path, "HEAD")); err == nil { 109 109 - repo, err := git.Open(path, "") 110 110 - if err != nil { 111 111 - log.Println(err) 112 112 - } else { 113 113 - relpath, _ := filepath.Rel(d.c.Repo.ScanPath, path) 114 114 - repos = append(repos, repoInfo{ 115 115 - Git: repo, 116 116 - Path: relpath, 117 117 - Category: d.category(path), 118 118 - }) 119 119 - // Since we found a Git repo, we don't want to recurse 120 120 - // further 121 121 - return fs.SkipDir 122 122 - } 123 123 - } 124 124 - } 125 125 - return nil 126 126 - }) 127 127 - 128 128 - return repos, err 129 129 - } 130 130 - 131 131 - func (d *Handle) category(path string) string { 132 132 - return strings.TrimPrefix(filepath.Dir(strings.TrimPrefix(path, d.c.Repo.ScanPath)), string(os.PathSeparator)) 133 133 - } 134 134 - 135 135 - func setContentDisposition(w http.ResponseWriter, name string) { 136 136 - h := "inline; filename=\"" + name + "\"" 137 137 - w.Header().Add("Content-Disposition", h) 138 138 - } 139 139 - 140 140 - func setGZipMIME(w http.ResponseWriter) { 141 141 - setMIME(w, "application/gzip") 142 142 - } 143 143 - 144 144 - func setMIME(w http.ResponseWriter, mime string) { 145 145 - w.Header().Add("Content-Type", mime) 146 146 - }

static/legit.png

This is a binary file and will not be displayed.

-341

static/style.css

··· 1 1 - :root { 2 2 - --white: #fff; 3 3 - --light: #f4f4f4; 4 4 - --cyan: #509c93; 5 5 - --light-gray: #eee; 6 6 - --medium-gray: #ddd; 7 7 - --gray: #6a6a6a; 8 8 - --dark: #444; 9 9 - --darker: #222; 10 10 - 11 11 - --sans-font: -apple-system, BlinkMacSystemFont, "Inter", "Roboto", 12 12 - "Segoe UI", sans-serif; 13 13 - --display-font: -apple-system, BlinkMacSystemFont, "Inter", "Roboto", 14 14 - "Segoe UI", sans-serif; 15 15 - --mono-font: "SF Mono", SFMono-Regular, ui-monospace, "DejaVu Sans Mono", 16 16 - "Roboto Mono", Menlo, Consolas, monospace; 17 17 - } 18 18 - 19 19 - @media (prefers-color-scheme: dark) { 20 20 - :root { 21 21 - color-scheme: dark light; 22 22 - --white: #000; 23 23 - --light: #181818; 24 24 - --cyan: #76c7c0; 25 25 - --light-gray: #333; 26 26 - --medium-gray: #444; 27 27 - --gray: #aaa; 28 28 - --dark: #ddd; 29 29 - --darker: #f4f4f4; 30 30 - } 31 31 - } 32 32 - 33 33 - html { 34 34 - background: var(--white); 35 35 - -webkit-text-size-adjust: none; 36 36 - font-family: var(--sans-font); 37 37 - font-weight: 380; 38 38 - } 39 39 - 40 40 - pre { 41 41 - font-family: var(--mono-font); 42 42 - } 43 43 - 44 44 - ::selection { 45 45 - background: var(--medium-gray); 46 46 - opacity: 0.3; 47 47 - } 48 48 - 49 49 - * { 50 50 - box-sizing: border-box; 51 51 - padding: 0; 52 52 - margin: 0; 53 53 - } 54 54 - 55 55 - body { 56 56 - max-width: 1000px; 57 57 - padding: 0 13px; 58 58 - margin: 40px auto; 59 59 - } 60 60 - 61 61 - main, 62 62 - footer { 63 63 - font-size: 1rem; 64 64 - padding: 0; 65 65 - line-height: 160%; 66 66 - } 67 67 - 68 68 - header h1, 69 69 - h2, 70 70 - h3 { 71 71 - font-family: var(--display-font); 72 72 - } 73 73 - 74 74 - h2 { 75 75 - font-weight: 400; 76 76 - } 77 77 - 78 78 - strong { 79 79 - font-weight: 500; 80 80 - } 81 81 - 82 82 - main h1 { 83 83 - padding: 10px 0 10px 0; 84 84 - } 85 85 - 86 86 - main h2 { 87 87 - font-size: 18px; 88 88 - } 89 89 - 90 90 - main h2, 91 91 - h3 { 92 92 - padding: 20px 0 15px 0; 93 93 - } 94 94 - 95 95 - nav { 96 96 - padding: 0.4rem 0 1.5rem 0; 97 97 - } 98 98 - 99 99 - nav ul { 100 100 - padding: 0; 101 101 - margin: 0; 102 102 - list-style: none; 103 103 - padding-bottom: 20px; 104 104 - } 105 105 - 106 106 - nav ul li { 107 107 - padding-right: 10px; 108 108 - display: inline-block; 109 109 - } 110 110 - 111 111 - a { 112 112 - margin: 0; 113 113 - padding: 0; 114 114 - box-sizing: border-box; 115 115 - text-decoration: none; 116 116 - word-wrap: break-word; 117 117 - } 118 118 - 119 119 - a { 120 120 - color: var(--darker); 121 121 - border-bottom: 1.5px solid var(--medium-gray); 122 122 - } 123 123 - 124 124 - a:hover { 125 125 - border-bottom: 1.5px solid var(--gray); 126 126 - } 127 127 - 128 128 - .index { 129 129 - padding-top: 2em; 130 130 - display: grid; 131 131 - grid-template-columns: 6em 1fr minmax(0, 7em); 132 132 - grid-row-gap: 0.5em; 133 133 - min-width: 0; 134 134 - } 135 135 - 136 136 - .clone-url { 137 137 - padding-top: 2rem; 138 138 - } 139 139 - 140 140 - .clone-url pre { 141 141 - color: var(--dark); 142 142 - white-space: pre-wrap; 143 143 - } 144 144 - 145 145 - .desc { 146 146 - font-weight: normal; 147 147 - color: var(--gray); 148 148 - font-style: italic; 149 149 - } 150 150 - 151 151 - .tree { 152 152 - display: grid; 153 153 - grid-template-columns: 10ch auto 1fr; 154 154 - grid-row-gap: 0.5em; 155 155 - grid-column-gap: 1em; 156 156 - min-width: 0; 157 157 - } 158 158 - 159 159 - .log { 160 160 - display: grid; 161 161 - grid-template-columns: 20rem minmax(0, 1fr); 162 162 - grid-row-gap: 0.8em; 163 163 - grid-column-gap: 8rem; 164 164 - margin-bottom: 2em; 165 165 - padding-bottom: 1em; 166 166 - border-bottom: 1.5px solid var(--medium-gray); 167 167 - } 168 168 - 169 169 - .log pre { 170 170 - white-space: pre-wrap; 171 171 - } 172 172 - 173 173 - .mode, 174 174 - .size { 175 175 - font-family: var(--mono-font); 176 176 - } 177 177 - .size { 178 178 - text-align: right; 179 179 - } 180 180 - 181 181 - .readme pre { 182 182 - white-space: pre-wrap; 183 183 - overflow-x: auto; 184 184 - } 185 185 - 186 186 - .readme { 187 187 - background: var(--light-gray); 188 188 - padding: 0.5rem; 189 189 - } 190 190 - 191 191 - .readme ul { 192 192 - padding: revert; 193 193 - } 194 194 - 195 195 - .readme img { 196 196 - max-width: 100%; 197 197 - } 198 198 - 199 199 - .diff { 200 200 - margin: 1rem 0 1rem 0; 201 201 - padding: 1rem 0 1rem 0; 202 202 - border-bottom: 1.5px solid var(--medium-gray); 203 203 - } 204 204 - 205 205 - .diff pre { 206 206 - overflow: scroll; 207 207 - } 208 208 - 209 209 - .diff-stat { 210 210 - padding: 1rem 0 1rem 0; 211 211 - } 212 212 - 213 213 - .commit-hash, 214 214 - .commit-email { 215 215 - font-family: var(--mono-font); 216 216 - } 217 217 - 218 218 - .commit-email:before { 219 219 - content: "<"; 220 220 - } 221 221 - 222 222 - .commit-email:after { 223 223 - content: ">"; 224 224 - } 225 225 - 226 226 - .commit { 227 227 - margin-bottom: 1rem; 228 228 - } 229 229 - 230 230 - .commit pre { 231 231 - padding-bottom: 1rem; 232 232 - white-space: pre-wrap; 233 233 - } 234 234 - 235 235 - .diff-stat ul li { 236 236 - list-style: none; 237 237 - padding-left: 0.5em; 238 238 - } 239 239 - 240 240 - .diff-add { 241 241 - color: green; 242 242 - } 243 243 - 244 244 - .diff-del { 245 245 - color: red; 246 246 - } 247 247 - 248 248 - .diff-noop { 249 249 - color: var(--gray); 250 250 - } 251 251 - 252 252 - .ref { 253 253 - font-family: var(--sans-font); 254 254 - font-size: 14px; 255 255 - color: var(--gray); 256 256 - display: inline-block; 257 257 - padding-top: 0.7em; 258 258 - } 259 259 - 260 260 - .refs pre { 261 261 - white-space: pre-wrap; 262 262 - padding-bottom: 0.5rem; 263 263 - } 264 264 - 265 265 - .refs strong { 266 266 - padding-right: 1em; 267 267 - } 268 268 - 269 269 - .line-numbers { 270 270 - white-space: pre-line; 271 271 - -moz-user-select: -moz-none; 272 272 - -khtml-user-select: none; 273 273 - -webkit-user-select: none; 274 274 - -o-user-select: none; 275 275 - user-select: none; 276 276 - display: flex; 277 277 - float: left; 278 278 - flex-direction: column; 279 279 - margin-right: 1ch; 280 280 - } 281 281 - 282 282 - .file-wrapper { 283 283 - display: flex; 284 284 - flex-direction: row; 285 285 - grid-template-columns: 1rem minmax(0, 1fr); 286 286 - gap: 1rem; 287 287 - padding: 0.5rem; 288 288 - background: var(--light-gray); 289 289 - overflow-x: auto; 290 290 - } 291 291 - 292 292 - .chroma-file-wrapper { 293 293 - display: flex; 294 294 - flex-direction: row; 295 295 - grid-template-columns: 1rem minmax(0, 1fr); 296 296 - overflow-x: auto; 297 297 - } 298 298 - 299 299 - .file-content { 300 300 - background: var(--light-gray); 301 301 - overflow-y: hidden; 302 302 - overflow-x: auto; 303 303 - } 304 304 - 305 305 - .diff-type { 306 306 - color: var(--gray); 307 307 - } 308 308 - 309 309 - .commit-info { 310 310 - color: var(--gray); 311 311 - padding-bottom: 1.5rem; 312 312 - font-size: 0.85rem; 313 313 - } 314 314 - 315 315 - @media (max-width: 600px) { 316 316 - .index { 317 317 - grid-row-gap: 0.8em; 318 318 - } 319 319 - 320 320 - .log { 321 321 - grid-template-columns: 1fr; 322 322 - grid-row-gap: 0em; 323 323 - } 324 324 - 325 325 - .index { 326 326 - grid-template-columns: 1fr; 327 327 - grid-row-gap: 0em; 328 328 - } 329 329 - 330 330 - .index-name:not(:first-child) { 331 331 - padding-top: 1.5rem; 332 332 - } 333 333 - 334 334 - .commit-info:not(:last-child) { 335 335 - padding-bottom: 1.5rem; 336 336 - } 337 337 - 338 338 - pre { 339 339 - font-size: 0.8rem; 340 340 - } 341 341 - }

-10

templates/errors/404.html

··· 1 1 - <html> 2 2 - <title>404</title> 3 3 - {{ template "layouts/head" . }} 4 4 - <body> 5 5 - {{ template "layouts/nav" . }} 6 6 - <main> 7 7 - <h3>404 &mdash; nothing like that here.</h3> 8 8 - </main> 9 9 - </body> 10 10 - </html>

-10

templates/errors/500.html

··· 1 1 - <html> 2 2 - <title>500</title> 3 3 - {{ template "layouts/head" . }} 4 4 - <body> 5 5 - {{ template "layouts/nav" . }} 6 6 - <main> 7 7 - <h3>500 &mdash; something broke!</h3> 8 8 - </main> 9 9 - </body> 10 10 - </html>

-21

templates/index.html

··· 1 1 - {{ define "index" }} 2 2 - <html> 3 3 - {{ template "layouts/head" . }} 4 4 - 5 5 - <header> 6 6 - <h1>{{ .meta.Title }}</h1> 7 7 - <h2>{{ .meta.Description }}</h2> 8 8 - </header> 9 9 - <body> 10 10 - <main> 11 11 - <div class="index"> 12 12 - {{ range .info }} 13 13 - <div class="index-name"><a href="/{{ .Name }}">{{ .DisplayName }}</a></div> 14 14 - <div class="desc">{{ .Desc }}</div> 15 15 - <div>{{ .Idle }}</div> 16 16 - {{ end }} 17 17 - </div> 18 18 - </main> 19 19 - </body> 20 20 - </html> 21 21 - {{ end }}

-37

templates/layouts/head.html

··· 1 1 - <head> 2 2 - <meta charset="utf-8" /> 3 3 - <meta name="viewport" content="width=device-width, initial-scale=1" /> 4 4 - <link rel="stylesheet" href="/static/style.css" type="text/css" /> 5 5 - <link rel="icon" type="image/png" size="32x32" href="/static/legit.png" /> 6 6 - <script src="https://unpkg.com/htmx.org@2.0.4"></script> 7 7 - <meta name="htmx-config" content='{"selfRequestsOnly":false}' /> 8 8 - 9 9 - {{ if .parent }} 10 10 - <title> 11 11 - {{ .meta.Title }} &mdash; {{ .name }} ({{ .ref }}): {{ .parent }}/ 12 12 - </title> 13 13 - 14 14 - {{ else if .path }} 15 15 - <title> 16 16 - {{ .meta.Title }} &mdash; {{ .name }} ({{ .ref }}): {{ .path }} 17 17 - </title> 18 18 - {{ else if .files }} 19 19 - <title>{{ .meta.Title }} &mdash; {{ .name }} ({{ .ref }})</title> 20 20 - {{ else if .commit }} 21 21 - <title>{{ .meta.Title }} &mdash; {{ .name }}: {{ .commit.This }}</title> 22 22 - {{ else if .branches }} 23 23 - <title>{{ .meta.Title }} &mdash; {{ .name }}: refs</title> 24 24 - {{ else if .commits }} {{ if .log }} 25 25 - <title>{{ .meta.Title }} &mdash; {{ .name }}: log</title> 26 26 - {{ else }} 27 27 - <title>{{ .meta.Title }} &mdash; {{ .name }}</title> 28 28 - {{ end }} {{ else }} 29 29 - <title>{{ .meta.Title }}</title> 30 30 - {{ end }} {{ if and .servername .gomod }} 31 31 - <meta 32 32 - name="go-import" 33 33 - content="{{ .servername}}/{{ .name }} git https://{{ .servername }}/{{ .name }}" 34 34 - /> 35 35 - {{ end }} 36 36 - <!-- other meta tags here --> 37 37 - </head>

-12

templates/layouts/nav.html

··· 1 1 - <nav> 2 2 - <ul> 3 3 - {{ if .name }} 4 4 - <li><a href="/{{ .name }}">summary</a></li> 5 5 - <li><a href="/{{ .name }}/refs">refs</a> {{ if .ref }}</li> 6 6 - 7 7 - <li><a href="/{{ .name }}/tree/{{ .ref }}/">tree</a></li> 8 8 - <li> 9 9 - <a href="/{{ .name }}/log/{{ .ref }}">log</a> {{ end }} {{ end }} 10 10 - </li> 11 11 - </ul> 12 12 - </nav>

-9

templates/layouts/repo-header.html

··· 1 1 - <header> 2 2 - <h2> 3 3 - <a href="/">all repos</a> 4 4 - &mdash; {{ .displayname }} {{ if .ref }} 5 5 - <span class="ref">@ {{ .ref }}</span> 6 6 - {{ end }} 7 7 - </h2> 8 8 - <h3 class="desc">{{ .desc }}</h3> 9 9 - </header>

-12

templates/layouts/topbar.html

··· 1 1 - <nav> 2 2 - <ul> 3 3 - {{ if . }} 4 4 - <li>logged in as 5 5 - <a href="/@{{ .handle }}">{{ .handle }}</a> (with {{ .did }}) 6 6 - </li> 7 7 - {{ else }} 8 8 - <li><a href="/login">login</a></li> 9 9 - {{ end }} 10 10 - </ul> 11 11 - </nav> 12 12 -

-100

templates/repo/commit.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - {{ template "layouts/repo-header" . }} 5 5 - <body> 6 6 - {{ template "layouts/nav" . }} 7 7 - <main> 8 8 - <section class="commit"> 9 9 - <pre>{{- .commit.Message -}}</pre> 10 10 - <div class="commit-info"> 11 11 - {{ .commit.Author.Name }} <a href="mailto:{{ .commit.Author.Email }}" class="commit-email">{{ .commit.Author.Email}}</a> 12 12 - <div>{{ .commit.Author.When.Format "Mon, 02 Jan 2006 15:04:05 -0700" }}</div> 13 13 - </div> 14 14 - 15 15 - <div> 16 16 - <strong>commit</strong> 17 17 - <p><a href="/{{ .name }}/commit/{{ .commit.This }}" class="commit-hash"> 18 18 - {{ .commit.This }} 19 19 - </a> 20 20 - </p> 21 21 - </div> 22 22 - 23 23 - {{ if .commit.Parent }} 24 24 - <div> 25 25 - <strong>parent</strong> 26 26 - <p><a href="/{{ .name }}/commit/{{ .commit.Parent }}" class="commit-hash"> 27 27 - {{ .commit.Parent }} 28 28 - </a></p> 29 29 - </div> 30 30 - 31 31 - {{ end }} 32 32 - <div class="diff-stat"> 33 33 - <div> 34 34 - {{ .stat.FilesChanged }} files changed, 35 35 - {{ .stat.Insertions }} insertions(+), 36 36 - {{ .stat.Deletions }} deletions(-) 37 37 - </div> 38 38 - <div> 39 39 - <br> 40 40 - <strong>jump to</strong> 41 41 - {{ range .diff }} 42 42 - <ul> 43 43 - <li><a href="#{{ .Name.New }}">{{ .Name.New }}</a></li> 44 44 - </ul> 45 45 - {{ end }} 46 46 - </div> 47 47 - </div> 48 48 - </section> 49 49 - <section> 50 50 - {{ $repo := .name }} 51 51 - {{ $this := .commit.This }} 52 52 - {{ $parent := .commit.Parent }} 53 53 - {{ range .diff }} 54 54 - <div id="{{ .Name.New }}"> 55 55 - <div class="diff"> 56 56 - {{ if .IsNew }} 57 57 - <span class="diff-type">A</span> 58 58 - {{ end }} 59 59 - {{ if .IsDelete }} 60 60 - <span class="diff-type">D</span> 61 61 - {{ end }} 62 62 - {{ if not (or .IsNew .IsDelete) }} 63 63 - <span class="diff-type">M</span> 64 64 - {{ end }} 65 65 - {{ if .Name.Old }} 66 66 - <a href="/{{ $repo }}/blob/{{ $parent }}/{{ .Name.Old }}">{{ .Name.Old }}</a> 67 67 - {{ if .Name.New }} 68 68 - &#8594; 69 69 - <a href="/{{ $repo }}/blob/{{ $this }}/{{ .Name.New }}">{{ .Name.New }}</a> 70 70 - {{ end }} 71 71 - {{ else }} 72 72 - <a href="/{{ $repo }}/blob/{{ $this }}/{{ .Name.New }}">{{ .Name.New }}</a> 73 73 - {{- end -}} 74 74 - {{ if .IsBinary }} 75 75 - <p>Not showing binary file.</p> 76 76 - {{ else }} 77 77 - <pre> 78 78 - {{- range .TextFragments -}} 79 79 - <p>{{- .Header -}}</p> 80 80 - {{- range .Lines -}} 81 81 - {{- if eq .Op.String "+" -}} 82 82 - <span class="diff-add">{{ .String }}</span> 83 83 - {{- end -}} 84 84 - {{- if eq .Op.String "-" -}} 85 85 - <span class="diff-del">{{ .String }}</span> 86 86 - {{- end -}} 87 87 - {{- if eq .Op.String " " -}} 88 88 - <span class="diff-noop">{{ .String }}</span> 89 89 - {{- end -}} 90 90 - {{- end -}} 91 91 - {{- end -}} 92 92 - {{- end -}} 93 93 - </pre> 94 94 - </div> 95 95 - </div> 96 96 - {{ end }} 97 97 - </section> 98 98 - </main> 99 99 - </body> 100 100 - </html>

-9

templates/repo/empty.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - <body> 5 5 - <main> 6 6 - <p>This is an empty Git repository. Push some commits here.</p> 7 7 - </main> 8 8 - </body> 9 9 - </html>

-34

templates/repo/file.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - {{ template "layouts/repo-header" . }} 4 4 - <body> 5 5 - {{ template "layouts/nav" . }} 6 6 - <main> 7 7 - <p>{{ .path }} (<a style="color: gray" href="?raw=true">view raw</a>)</p> 8 8 - {{if .chroma }} 9 9 - <div class="chroma-file-wrapper"> 10 10 - {{ .content }} 11 11 - </div> 12 12 - {{else}} 13 13 - <div class="file-wrapper"> 14 14 - <table> 15 15 - <tbody><tr> 16 16 - <td class="line-numbers"> 17 17 - <pre> 18 18 - {{- range .linecount }} 19 19 - <a id="L{{ . }}" href="#L{{ . }}">{{ . }}</a> 20 20 - {{- end -}} 21 21 - </pre> 22 22 - </td> 23 23 - <td class="file-content"> 24 24 - <pre> 25 25 - {{- .content -}} 26 26 - </pre> 27 27 - </td> 28 28 - </tbody></tr> 29 29 - </table> 30 30 - </div> 31 31 - {{end}} 32 32 - </main> 33 33 - </body> 34 34 - </html>

-23

templates/repo/log.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - {{ template "layouts/repo-header" . }} 5 5 - <body> 6 6 - {{ template "layouts/nav" . }} 7 7 - <main> 8 8 - {{ $repo := .name }} 9 9 - <div class="log"> 10 10 - {{ range .commits }} 11 11 - <div> 12 12 - <div><a href="/{{ $repo }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div> 13 13 - <pre>{{ .Message }}</pre> 14 14 - </div> 15 15 - <div class="commit-info"> 16 16 - {{ .Author.Name }} <a href="mailto:{{ .Author.Email }}" class="commit-email">{{ .Author.Email }}</a> 17 17 - <div>{{ .Author.When.Format "Mon, 02 Jan 2006 15:04:05 -0700" }}</div> 18 18 - </div> 19 19 - {{ end }} 20 20 - </div> 21 21 - </main> 22 22 - </body> 23 23 - </html>

-30

templates/repo/new.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - <body> 5 5 - <main> 6 6 - <h1>create a new repository</h1> 7 7 - <form> 8 8 - <p> 9 9 - Give your Git repository a name and, optionally, a 10 10 - description. 11 11 - </p> 12 12 - <div id="repo"></div> 13 13 - <div> 14 14 - <label for="name">Name</label> 15 15 - <input type="text" id="name" name="name" placeholder="" /> 16 16 - <label for="description">Description</label> 17 17 - <input 18 18 - type="text" 19 19 - id="description" 20 20 - name="description" 21 21 - placeholder="" 22 22 - /> 23 23 - </div> 24 24 - <button hx-put="/repo/new" hx-swap="none" type="submit"> 25 25 - Submit 26 26 - </button> 27 27 - </form> 28 28 - </main> 29 29 - </body> 30 30 - </html>

-38

templates/repo/refs.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - {{ template "layouts/repo-header" . }} 5 5 - <body> 6 6 - {{ template "layouts/nav" . }} 7 7 - <main> 8 8 - {{ $name := .name }} 9 9 - <h3>branches</h3> 10 10 - <div class="refs"> 11 11 - {{ range .branches }} 12 12 - <div> 13 13 - <strong>{{ .Name.Short }}</strong> 14 14 - <a href="/{{ $name }}/tree/{{ .Name.Short }}/">browse</a> 15 15 - <a href="/{{ $name }}/log/{{ .Name.Short }}">log</a> 16 16 - <a href="/{{ $name }}/archive/{{ .Name.Short }}.tar.gz">tar.gz</a> 17 17 - </div> 18 18 - {{ end }} 19 19 - </div> 20 20 - {{ if .tags }} 21 21 - <h3>tags</h3> 22 22 - <div class="refs"> 23 23 - {{ range .tags }} 24 24 - <div> 25 25 - <strong>{{ .Name }}</strong> 26 26 - <a href="/{{ $name }}/tree/{{ .Name }}/">browse</a> 27 27 - <a href="/{{ $name }}/log/{{ .Name }}">log</a> 28 28 - <a href="/{{ $name }}/archive/{{ .Name }}.tar.gz">tar.gz</a> 29 29 - {{ if .Message }} 30 30 - <pre>{{ .Message }}</pre> 31 31 - </div> 32 32 - {{ end }} 33 33 - {{ end }} 34 34 - </div> 35 35 - {{ end }} 36 36 - </main> 37 37 - </body> 38 38 - </html>

-36

templates/repo/repo.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - {{ template "layouts/repo-header" . }} 5 5 - 6 6 - <body> 7 7 - {{ template "layouts/nav" . }} 8 8 - <main> 9 9 - {{ $repo := .name }} 10 10 - <div class="log"> 11 11 - {{ range .commits }} 12 12 - <div> 13 13 - <div><a href="/{{ $repo }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div> 14 14 - <pre>{{ .Message }}</pre> 15 15 - </div> 16 16 - <div class="commit-info"> 17 17 - {{ .Author.Name }} <a href="mailto:{{ .Author.Email }}" class="commit-email">{{ .Author.Email }}</a> 18 18 - <div>{{ .Author.When.Format "Mon, 02 Jan 2006 15:04:05 -0700" }}</div> 19 19 - </div> 20 20 - {{ end }} 21 21 - </div> 22 22 - {{- if .readme }} 23 23 - <article class="readme"> 24 24 - {{- .readme -}} 25 25 - </article> 26 26 - {{- end -}} 27 27 - 28 28 - <div class="clone-url"> 29 29 - <strong>clone</strong> 30 30 - <pre> 31 31 - git clone https://{{ .servername }}/{{ .name }} 32 32 - </pre> 33 33 - </div> 34 34 - </main> 35 35 - </body> 36 36 - </html>

-53

templates/repo/tree.html

··· 1 1 - <html> 2 2 - 3 3 - {{ template "layouts/head" . }} 4 4 - 5 5 - {{ template "layouts/repo-header" . }} 6 6 - <body> 7 7 - {{ template "layouts/nav" . }} 8 8 - <main> 9 9 - {{ $repo := .name }} 10 10 - {{ $ref := .ref }} 11 11 - {{ $parent := .parent }} 12 12 - 13 13 - <div class="tree"> 14 14 - {{ if $parent }} 15 15 - <div></div> 16 16 - <div></div> 17 17 - <div><a href="/{{ $repo }}/tree/{{ $ref }}/{{ .dotdot }}">..</a></div> 18 18 - {{ end }} 19 19 - {{ range .files }} 20 20 - {{ if not .IsFile }} 21 21 - <div class="mode">{{ .Mode }}</div> 22 22 - <div class="size">{{ .Size }}</div> 23 23 - <div> 24 24 - {{ if $parent }} 25 25 - <a href="/{{ $repo }}/tree/{{ $ref }}/{{ $parent }}/{{ .Name }}">{{ .Name }}/</a> 26 26 - {{ else }} 27 27 - <a href="/{{ $repo }}/tree/{{ $ref }}/{{ .Name }}">{{ .Name }}/</a> 28 28 - {{ end }} 29 29 - </div> 30 30 - {{ end }} 31 31 - {{ end }} 32 32 - {{ range .files }} 33 33 - {{ if .IsFile }} 34 34 - <div class="mode">{{ .Mode }}</div> 35 35 - <div class="size">{{ .Size }}</div> 36 36 - <div> 37 37 - {{ if $parent }} 38 38 - <a href="/{{ $repo }}/blob/{{ $ref }}/{{ $parent }}/{{ .Name }}">{{ .Name }}</a> 39 39 - {{ else }} 40 40 - <a href="/{{ $repo }}/blob/{{ $ref }}/{{ .Name }}">{{ .Name }}</a> 41 41 - {{ end }} 42 42 - </div> 43 43 - {{ end }} 44 44 - {{ end }} 45 45 - </div> 46 46 - <article> 47 47 - <pre> 48 48 - {{- if .readme }}{{ .readme }}{{- end -}} 49 49 - </pre> 50 50 - </article> 51 51 - </main> 52 52 - </body> 53 53 - </html>

-51

templates/settings/keys.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - <body> 5 5 - <main> 6 6 - <form> 7 7 - <p> 8 8 - Give your key a name and paste your 9 9 - <strong>public</strong> key here. This is what you'll use to 10 10 - push to your Git repository. 11 11 - </p> 12 12 - <div id="keys"></div> 13 13 - <div> 14 14 - <input 15 15 - type="text" 16 16 - id="name" 17 17 - name="name" 18 18 - placeholder="my laptop" 19 19 - /> 20 20 - <input 21 21 - type="text" 22 22 - id="public_key" 23 23 - name="key" 24 24 - placeholder="ssh-ed25519 AAABBBHUNTER2..." 25 25 - /> 26 26 - </div> 27 27 - <button hx-put="/settings/keys" hx-swap="none" type="submit"> 28 28 - Submit 29 29 - </button> 30 30 - </form> 31 31 - <table> 32 32 - <thead> 33 33 - <tr> 34 34 - <th>Key</th> 35 35 - <th>Name</th> 36 36 - <th>Created</th> 37 37 - </tr> 38 38 - </thead> 39 39 - <tbody> 40 40 - {{ range .keys }} 41 41 - <tr> 42 42 - <td>{{ .Name }}</td> 43 43 - <td>{{ .Created }}</td> 44 44 - <td>{{ .Key }}</td> 45 45 - </tr> 46 46 - {{ end }} 47 47 - </tbody> 48 48 - </table> 49 49 - </main> 50 50 - </body> 51 51 - </html>

-14

templates/timeline.html

··· 1 1 - {{ define "timeline" }} 2 2 - <html> 3 3 - {{ template "layouts/head" . }} 4 4 - 5 5 - <header> 6 6 - <h1>timeline</h1> 7 7 - </header> 8 8 - <body> 9 9 - <main> 10 10 - {{ template "layouts/topbar" . }} 11 11 - </main> 12 12 - </body> 13 13 - </html> 14 14 - {{ end }}

-29

templates/user/login.html

··· 1 1 - <html> 2 2 - {{ template "layouts/head" . }} 3 3 - 4 4 - <body> 5 5 - <main> 6 6 - <form class="form-login" method="post" action="/login"> 7 7 - <p> 8 8 - You will be redirected to bsky.social (or your PDS) to 9 9 - complete login. 10 10 - </p> 11 11 - <div> 12 12 - <input 13 13 - type="text" 14 14 - id="username" 15 15 - name="username" 16 16 - placeholder="@username.bsky.social" 17 17 - /> 18 18 - <input 19 19 - type="password" 20 20 - id="app_password" 21 21 - name="app_password" 22 22 - placeholder="app password" 23 23 - /> 24 24 - </div> 25 25 - <button type="submit">Login</button> 26 26 - </form> 27 27 - </main> 28 28 - </body> 29 29 - </html>