+2

.tangled/workflows/build.yml

··· 2 2 - event: ["push", "pull_request"] 3 3 branch: ["master"] 4 4 5 5 + engine: nixery 6 6 + 5 7 dependencies: 6 8 nixpkgs: 7 9 - go

+2

.tangled/workflows/fmt.yml

··· 2 2 - event: ["push", "pull_request"] 3 3 branch: ["master"] 4 4 5 5 + engine: nixery 6 6 + 5 7 steps: 6 8 - name: "Check formatting" 7 9 command: |

+2

.tangled/workflows/test.yml

··· 2 2 - event: ["push", "pull_request"] 3 3 branch: ["master"] 4 4 5 5 + engine: nixery 6 6 + 5 7 dependencies: 6 8 nixpkgs: 7 9 - go

+2 -122

api/tangled/cbor_gen.go

··· 5512 5512 } 5513 5513 5514 5514 cw := cbg.NewCborWriter(w) 5515 5515 - fieldCount := 7 5515 5515 + fieldCount := 6 5516 5516 5517 5517 if t.Body == nil { 5518 5518 fieldCount-- ··· 5642 5642 return err 5643 5643 } 5644 5644 5645 5645 - // t.IssueId (int64) (int64) 5646 5646 - if len("issueId") > 1000000 { 5647 5647 - return xerrors.Errorf("Value in field \"issueId\" was too long") 5648 5648 - } 5649 5649 - 5650 5650 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil { 5651 5651 - return err 5652 5652 - } 5653 5653 - if _, err := cw.WriteString(string("issueId")); err != nil { 5654 5654 - return err 5655 5655 - } 5656 5656 - 5657 5657 - if t.IssueId >= 0 { 5658 5658 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil { 5659 5659 - return err 5660 5660 - } 5661 5661 - } else { 5662 5662 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil { 5663 5663 - return err 5664 5664 - } 5665 5665 - } 5666 5666 - 5667 5645 // t.CreatedAt (string) (string) 5668 5646 if len("createdAt") > 1000000 { 5669 5647 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 5795 5773 5796 5774 t.Title = string(sval) 5797 5775 } 5798 5798 - // t.IssueId (int64) (int64) 5799 5799 - case "issueId": 5800 5800 - { 5801 5801 - maj, extra, err := cr.ReadHeader() 5802 5802 - if err != nil { 5803 5803 - return err 5804 5804 - } 5805 5805 - var extraI int64 5806 5806 - switch maj { 5807 5807 - case cbg.MajUnsignedInt: 5808 5808 - extraI = int64(extra) 5809 5809 - if extraI < 0 { 5810 5810 - return fmt.Errorf("int64 positive overflow") 5811 5811 - } 5812 5812 - case cbg.MajNegativeInt: 5813 5813 - extraI = int64(extra) 5814 5814 - if extraI < 0 { 5815 5815 - return fmt.Errorf("int64 negative overflow") 5816 5816 - } 5817 5817 - extraI = -1 - extraI 5818 5818 - default: 5819 5819 - return fmt.Errorf("wrong type for int64 field: %d", maj) 5820 5820 - } 5821 5821 - 5822 5822 - t.IssueId = int64(extraI) 5823 5823 - } 5824 5776 // t.CreatedAt (string) (string) 5825 5777 case "createdAt": 5826 5778 ··· 5850 5802 } 5851 5803 5852 5804 cw := cbg.NewCborWriter(w) 5853 5853 - fieldCount := 7 5854 5854 - 5855 5855 - if t.CommentId == nil { 5856 5856 - fieldCount-- 5857 5857 - } 5805 5805 + fieldCount := 6 5858 5806 5859 5807 if t.Owner == nil { 5860 5808 fieldCount-- ··· 5997 5945 } 5998 5946 } 5999 5947 6000 6000 - // t.CommentId (int64) (int64) 6001 6001 - if t.CommentId != nil { 6002 6002 - 6003 6003 - if len("commentId") > 1000000 { 6004 6004 - return xerrors.Errorf("Value in field \"commentId\" was too long") 6005 6005 - } 6006 6006 - 6007 6007 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil { 6008 6008 - return err 6009 6009 - } 6010 6010 - if _, err := cw.WriteString(string("commentId")); err != nil { 6011 6011 - return err 6012 6012 - } 6013 6013 - 6014 6014 - if t.CommentId == nil { 6015 6015 - if _, err := cw.Write(cbg.CborNull); err != nil { 6016 6016 - return err 6017 6017 - } 6018 6018 - } else { 6019 6019 - if *t.CommentId >= 0 { 6020 6020 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil { 6021 6021 - return err 6022 6022 - } 6023 6023 - } else { 6024 6024 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil { 6025 6025 - return err 6026 6026 - } 6027 6027 - } 6028 6028 - } 6029 6029 - 6030 6030 - } 6031 6031 - 6032 5948 // t.CreatedAt (string) (string) 6033 5949 if len("createdAt") > 1000000 { 6034 5950 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 6168 6084 } 6169 6085 6170 6086 t.Owner = (*string)(&sval) 6171 6171 - } 6172 6172 - } 6173 6173 - // t.CommentId (int64) (int64) 6174 6174 - case "commentId": 6175 6175 - { 6176 6176 - 6177 6177 - b, err := cr.ReadByte() 6178 6178 - if err != nil { 6179 6179 - return err 6180 6180 - } 6181 6181 - if b != cbg.CborNull[0] { 6182 6182 - if err := cr.UnreadByte(); err != nil { 6183 6183 - return err 6184 6184 - } 6185 6185 - maj, extra, err := cr.ReadHeader() 6186 6186 - if err != nil { 6187 6187 - return err 6188 6188 - } 6189 6189 - var extraI int64 6190 6190 - switch maj { 6191 6191 - case cbg.MajUnsignedInt: 6192 6192 - extraI = int64(extra) 6193 6193 - if extraI < 0 { 6194 6194 - return fmt.Errorf("int64 positive overflow") 6195 6195 - } 6196 6196 - case cbg.MajNegativeInt: 6197 6197 - extraI = int64(extra) 6198 6198 - if extraI < 0 { 6199 6199 - return fmt.Errorf("int64 negative overflow") 6200 6200 - } 6201 6201 - extraI = -1 - extraI 6202 6202 - default: 6203 6203 - return fmt.Errorf("wrong type for int64 field: %d", maj) 6204 6204 - } 6205 6205 - 6206 6206 - t.CommentId = (*int64)(&extraI) 6207 6087 } 6208 6088 } 6209 6089 // t.CreatedAt (string) (string)

-1

api/tangled/issuecomment.go

··· 19 19 type RepoIssueComment struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"` 21 21 Body string `json:"body" cborgen:"body"` 22 22 - CommentId *int64 `json:"commentId,omitempty" cborgen:"commentId,omitempty"` 23 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 23 Issue string `json:"issue" cborgen:"issue"` 25 24 Owner *string `json:"owner,omitempty" cborgen:"owner,omitempty"`

-1

api/tangled/repoissue.go

··· 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"` 21 21 Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 - IssueId int64 `json:"issueId" cborgen:"issueId"` 24 23 Owner string `json:"owner" cborgen:"owner"` 25 24 Repo string `json:"repo" cborgen:"repo"` 26 25 Title string `json:"title" cborgen:"title"`

+4

appview/db/db.go

··· 470 470 id integer primary key autoincrement, 471 471 name text unique 472 472 ); 473 473 + 474 474 + -- indexes for better star query performance 475 475 + create index if not exists idx_stars_created on stars(created); 476 476 + create index if not exists idx_stars_repo_at_created on stars(repo_at, created); 473 477 `) 474 478 if err != nil { 475 479 return nil, err

+189 -3

appview/db/issues.go

··· 3 3 import ( 4 4 "database/sql" 5 5 "fmt" 6 6 + mathrand "math/rand/v2" 7 7 + "strings" 6 8 "time" 7 9 8 10 "github.com/bluesky-social/indigo/atproto/syntax" ··· 48 50 return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", i.OwnerDid, tangled.RepoIssueNSID, i.Rkey)) 49 51 } 50 52 53 53 + func IssueFromRecord(did, rkey string, record tangled.RepoIssue) Issue { 54 54 + created, err := time.Parse(time.RFC3339, record.CreatedAt) 55 55 + if err != nil { 56 56 + created = time.Now() 57 57 + } 58 58 + 59 59 + body := "" 60 60 + if record.Body != nil { 61 61 + body = *record.Body 62 62 + } 63 63 + 64 64 + return Issue{ 65 65 + RepoAt: syntax.ATURI(record.Repo), 66 66 + OwnerDid: record.Owner, 67 67 + Rkey: rkey, 68 68 + Created: created, 69 69 + Title: record.Title, 70 70 + Body: body, 71 71 + Open: true, // new issues are open by default 72 72 + } 73 73 + } 74 74 + 75 75 + func ResolveIssueFromAtUri(e Execer, issueUri syntax.ATURI) (syntax.ATURI, int, error) { 76 76 + ownerDid := issueUri.Authority().String() 77 77 + issueRkey := issueUri.RecordKey().String() 78 78 + 79 79 + var repoAt string 80 80 + var issueId int 81 81 + 82 82 + query := `select repo_at, issue_id from issues where owner_did = ? and rkey = ?` 83 83 + err := e.QueryRow(query, ownerDid, issueRkey).Scan(&repoAt, &issueId) 84 84 + if err != nil { 85 85 + return "", 0, err 86 86 + } 87 87 + 88 88 + return syntax.ATURI(repoAt), issueId, nil 89 89 + } 90 90 + 91 91 + func IssueCommentFromRecord(e Execer, did, rkey string, record tangled.RepoIssueComment) (Comment, error) { 92 92 + created, err := time.Parse(time.RFC3339, record.CreatedAt) 93 93 + if err != nil { 94 94 + created = time.Now() 95 95 + } 96 96 + 97 97 + ownerDid := did 98 98 + if record.Owner != nil { 99 99 + ownerDid = *record.Owner 100 100 + } 101 101 + 102 102 + issueUri, err := syntax.ParseATURI(record.Issue) 103 103 + if err != nil { 104 104 + return Comment{}, err 105 105 + } 106 106 + 107 107 + repoAt, issueId, err := ResolveIssueFromAtUri(e, issueUri) 108 108 + if err != nil { 109 109 + return Comment{}, err 110 110 + } 111 111 + 112 112 + comment := Comment{ 113 113 + OwnerDid: ownerDid, 114 114 + RepoAt: repoAt, 115 115 + Rkey: rkey, 116 116 + Body: record.Body, 117 117 + Issue: issueId, 118 118 + CommentId: mathrand.IntN(1000000), 119 119 + Created: &created, 120 120 + } 121 121 + 122 122 + return comment, nil 123 123 + } 124 124 + 51 125 func NewIssue(tx *sql.Tx, issue *Issue) error { 52 126 defer tx.Rollback() 53 127 ··· 105 179 return ownerDid, err 106 180 } 107 181 108 108 - func GetIssues(e Execer, repoAt syntax.ATURI, isOpen bool, page pagination.Page) ([]Issue, error) { 182 182 + func GetIssuesPaginated(e Execer, repoAt syntax.ATURI, isOpen bool, page pagination.Page) ([]Issue, error) { 109 183 var issues []Issue 110 184 openValue := 0 111 185 if isOpen { ··· 145 219 body, 146 220 open, 147 221 comment_count 148 148 - from 222 222 + from 149 223 numbered_issue 150 150 - where 224 224 + where 151 225 row_num between ? and ?`, 152 226 repoAt, openValue, page.Offset+1, page.Offset+page.Limit) 153 227 if err != nil { ··· 181 255 return issues, nil 182 256 } 183 257 258 258 + func GetIssuesWithLimit(e Execer, limit int, filters ...filter) ([]Issue, error) { 259 259 + issues := make([]Issue, 0, limit) 260 260 + 261 261 + var conditions []string 262 262 + var args []any 263 263 + for _, filter := range filters { 264 264 + conditions = append(conditions, filter.Condition()) 265 265 + args = append(args, filter.Arg()...) 266 266 + } 267 267 + 268 268 + whereClause := "" 269 269 + if conditions != nil { 270 270 + whereClause = " where " + strings.Join(conditions, " and ") 271 271 + } 272 272 + limitClause := "" 273 273 + if limit != 0 { 274 274 + limitClause = fmt.Sprintf(" limit %d ", limit) 275 275 + } 276 276 + 277 277 + query := fmt.Sprintf( 278 278 + `select 279 279 + i.id, 280 280 + i.owner_did, 281 281 + i.repo_at, 282 282 + i.issue_id, 283 283 + i.created, 284 284 + i.title, 285 285 + i.body, 286 286 + i.open 287 287 + from 288 288 + issues i 289 289 + %s 290 290 + order by 291 291 + i.created desc 292 292 + %s`, 293 293 + whereClause, limitClause) 294 294 + 295 295 + rows, err := e.Query(query, args...) 296 296 + if err != nil { 297 297 + return nil, err 298 298 + } 299 299 + defer rows.Close() 300 300 + 301 301 + for rows.Next() { 302 302 + var issue Issue 303 303 + var issueCreatedAt string 304 304 + err := rows.Scan( 305 305 + &issue.ID, 306 306 + &issue.OwnerDid, 307 307 + &issue.RepoAt, 308 308 + &issue.IssueId, 309 309 + &issueCreatedAt, 310 310 + &issue.Title, 311 311 + &issue.Body, 312 312 + &issue.Open, 313 313 + ) 314 314 + if err != nil { 315 315 + return nil, err 316 316 + } 317 317 + 318 318 + issueCreatedTime, err := time.Parse(time.RFC3339, issueCreatedAt) 319 319 + if err != nil { 320 320 + return nil, err 321 321 + } 322 322 + issue.Created = issueCreatedTime 323 323 + 324 324 + issues = append(issues, issue) 325 325 + } 326 326 + 327 327 + if err := rows.Err(); err != nil { 328 328 + return nil, err 329 329 + } 330 330 + 331 331 + return issues, nil 332 332 + } 333 333 + 334 334 + func GetIssues(e Execer, filters ...filter) ([]Issue, error) { 335 335 + return GetIssuesWithLimit(e, 0, filters...) 336 336 + } 337 337 + 184 338 // timeframe here is directly passed into the sql query filter, and any 185 339 // timeframe in the past should be negative; e.g.: "-3 months" 186 340 func GetIssuesByOwnerDid(e Execer, ownerDid string, timeframe string) ([]Issue, error) { ··· 469 623 deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 470 624 where repo_at = ? and issue_id = ? and comment_id = ? 471 625 `, repoAt, issueId, commentId) 626 626 + return err 627 627 + } 628 628 + 629 629 + func UpdateCommentByRkey(e Execer, ownerDid, rkey, newBody string) error { 630 630 + _, err := e.Exec( 631 631 + ` 632 632 + update comments 633 633 + set body = ?, 634 634 + edited = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 635 635 + where owner_did = ? and rkey = ? 636 636 + `, newBody, ownerDid, rkey) 637 637 + return err 638 638 + } 639 639 + 640 640 + func DeleteCommentByRkey(e Execer, ownerDid, rkey string) error { 641 641 + _, err := e.Exec( 642 642 + ` 643 643 + update comments 644 644 + set body = "", 645 645 + deleted = strftime('%Y-%m-%dT%H:%M:%SZ', 'now') 646 646 + where owner_did = ? and rkey = ? 647 647 + `, ownerDid, rkey) 648 648 + return err 649 649 + } 650 650 + 651 651 + func UpdateIssueByRkey(e Execer, ownerDid, rkey, title, body string) error { 652 652 + _, err := e.Exec(`update issues set title = ?, body = ? where owner_did = ? and rkey = ?`, title, body, ownerDid, rkey) 653 653 + return err 654 654 + } 655 655 + 656 656 + func DeleteIssueByRkey(e Execer, ownerDid, rkey string) error { 657 657 + _, err := e.Exec(`delete from issues where owner_did = ? and rkey = ?`, ownerDid, rkey) 472 658 return err 473 659 } 474 660

+22 -3

appview/db/pulls.go

··· 310 310 return pullId - 1, err 311 311 } 312 312 313 313 - func GetPulls(e Execer, filters ...filter) ([]*Pull, error) { 313 313 + func GetPullsWithLimit(e Execer, limit int, filters ...filter) ([]*Pull, error) { 314 314 pulls := make(map[int]*Pull) 315 315 316 316 var conditions []string ··· 323 323 whereClause := "" 324 324 if conditions != nil { 325 325 whereClause = " where " + strings.Join(conditions, " and ") 326 326 + } 327 327 + limitClause := "" 328 328 + if limit != 0 { 329 329 + limitClause = fmt.Sprintf(" limit %d ", limit) 326 330 } 327 331 328 332 query := fmt.Sprintf(` ··· 344 348 from 345 349 pulls 346 350 %s 347 347 - `, whereClause) 351 351 + order by 352 352 + created desc 353 353 + %s 354 354 + `, whereClause, limitClause) 348 355 349 356 rows, err := e.Query(query, args...) 350 357 if err != nil { ··· 412 419 inClause := strings.TrimSuffix(strings.Repeat("?, ", len(pulls)), ", ") 413 420 submissionsQuery := fmt.Sprintf(` 414 421 select 415 415 - id, pull_id, round_number, patch, source_rev 422 422 + id, pull_id, round_number, patch, created, source_rev 416 423 from 417 424 pull_submissions 418 425 where ··· 438 445 for submissionsRows.Next() { 439 446 var s PullSubmission 440 447 var sourceRev sql.NullString 448 448 + var createdAt string 441 449 err := submissionsRows.Scan( 442 450 &s.ID, 443 451 &s.PullId, 444 452 &s.RoundNumber, 445 453 &s.Patch, 454 454 + &createdAt, 446 455 &sourceRev, 447 456 ) 448 457 if err != nil { 449 458 return nil, err 450 459 } 460 460 + 461 461 + createdTime, err := time.Parse(time.RFC3339, createdAt) 462 462 + if err != nil { 463 463 + return nil, err 464 464 + } 465 465 + s.Created = createdTime 451 466 452 467 if sourceRev.Valid { 453 468 s.SourceRev = sourceRev.String ··· 511 526 }) 512 527 513 528 return orderedByPullId, nil 529 529 + } 530 530 + 531 531 + func GetPulls(e Execer, filters ...filter) ([]*Pull, error) { 532 532 + return GetPullsWithLimit(e, 0, filters...) 514 533 } 515 534 516 535 func GetPull(e Execer, repoAt syntax.ATURI, pullId int) (*Pull, error) {

+72 -3

appview/db/star.go

··· 47 47 // Get a star record 48 48 func GetStar(e Execer, starredByDid string, repoAt syntax.ATURI) (*Star, error) { 49 49 query := ` 50 50 - select starred_by_did, repo_at, created, rkey 50 50 + select starred_by_did, repo_at, created, rkey 51 51 from stars 52 52 where starred_by_did = ? and repo_at = ?` 53 53 row := e.QueryRow(query, starredByDid, repoAt) ··· 119 119 } 120 120 121 121 repoQuery := fmt.Sprintf( 122 122 - `select starred_by_did, repo_at, created, rkey 122 122 + `select starred_by_did, repo_at, created, rkey 123 123 from stars 124 124 %s 125 125 order by created desc ··· 187 187 var stars []Star 188 188 189 189 rows, err := e.Query(` 190 190 - select 190 190 + select 191 191 s.starred_by_did, 192 192 s.repo_at, 193 193 s.rkey, ··· 244 244 245 245 return stars, nil 246 246 } 247 247 + 248 248 + // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week 249 249 + func GetTopStarredReposLastWeek(e Execer) ([]Repo, error) { 250 250 + // first, get the top repo URIs by star count from the last week 251 251 + query := ` 252 252 + with recent_starred_repos as ( 253 253 + select distinct repo_at 254 254 + from stars 255 255 + where created >= datetime('now', '-7 days') 256 256 + ), 257 257 + repo_star_counts as ( 258 258 + select 259 259 + s.repo_at, 260 260 + count(*) as star_count 261 261 + from stars s 262 262 + join recent_starred_repos rsr on s.repo_at = rsr.repo_at 263 263 + group by s.repo_at 264 264 + ) 265 265 + select rsc.repo_at 266 266 + from repo_star_counts rsc 267 267 + order by rsc.star_count desc 268 268 + limit 8 269 269 + ` 270 270 + 271 271 + rows, err := e.Query(query) 272 272 + if err != nil { 273 273 + return nil, err 274 274 + } 275 275 + defer rows.Close() 276 276 + 277 277 + var repoUris []string 278 278 + for rows.Next() { 279 279 + var repoUri string 280 280 + err := rows.Scan(&repoUri) 281 281 + if err != nil { 282 282 + return nil, err 283 283 + } 284 284 + repoUris = append(repoUris, repoUri) 285 285 + } 286 286 + 287 287 + if err := rows.Err(); err != nil { 288 288 + return nil, err 289 289 + } 290 290 + 291 291 + if len(repoUris) == 0 { 292 292 + return []Repo{}, nil 293 293 + } 294 294 + 295 295 + // get full repo data 296 296 + repos, err := GetRepos(e, 0, FilterIn("at_uri", repoUris)) 297 297 + if err != nil { 298 298 + return nil, err 299 299 + } 300 300 + 301 301 + // sort repos by the original trending order 302 302 + repoMap := make(map[string]Repo) 303 303 + for _, repo := range repos { 304 304 + repoMap[repo.RepoAt().String()] = repo 305 305 + } 306 306 + 307 307 + orderedRepos := make([]Repo, 0, len(repoUris)) 308 308 + for _, uri := range repoUris { 309 309 + if repo, exists := repoMap[uri]; exists { 310 310 + orderedRepos = append(orderedRepos, repo) 311 311 + } 312 312 + } 313 313 + 314 314 + return orderedRepos, nil 315 315 + }

+12 -11

appview/db/strings.go

··· 50 50 func (s String) Validate() error { 51 51 var err error 52 52 53 53 - if !strings.Contains(s.Filename, ".") { 54 54 - err = errors.Join(err, fmt.Errorf("missing filename extension")) 55 55 - } 56 56 - 57 57 - if strings.HasSuffix(s.Filename, ".") { 58 58 - err = errors.Join(err, fmt.Errorf("filename ends with `.`")) 59 59 - } 60 60 - 61 53 if utf8.RuneCountInString(s.Filename) > 140 { 62 54 err = errors.Join(err, fmt.Errorf("filename too long")) 63 55 } ··· 113 105 filename = excluded.filename, 114 106 description = excluded.description, 115 107 content = excluded.content, 116 116 - edited = case 108 108 + edited = case 117 109 when 118 110 strings.content != excluded.content 119 111 or strings.filename != excluded.filename ··· 131 123 return err 132 124 } 133 125 134 134 - func GetStrings(e Execer, filters ...filter) ([]String, error) { 126 126 + func GetStrings(e Execer, limit int, filters ...filter) ([]String, error) { 135 127 var all []String 136 128 137 129 var conditions []string ··· 146 138 whereClause = " where " + strings.Join(conditions, " and ") 147 139 } 148 140 141 141 + limitClause := "" 142 142 + if limit != 0 { 143 143 + limitClause = fmt.Sprintf(" limit %d ", limit) 144 144 + } 145 145 + 149 146 query := fmt.Sprintf(`select 150 147 did, 151 148 rkey, ··· 154 151 content, 155 152 created, 156 153 edited 157 157 - from strings %s`, 154 154 + from strings 155 155 + %s 156 156 + order by created desc 157 157 + %s`, 158 158 whereClause, 159 159 + limitClause, 159 160 ) 160 161 161 162 rows, err := e.Query(query, args...)

+179 -6

appview/ingester.go

··· 5 5 "encoding/json" 6 6 "fmt" 7 7 "log/slog" 8 8 + "strings" 8 9 "time" 9 10 10 11 "github.com/bluesky-social/indigo/atproto/syntax" ··· 14 15 "tangled.sh/tangled.sh/core/api/tangled" 15 16 "tangled.sh/tangled.sh/core/appview/config" 16 17 "tangled.sh/tangled.sh/core/appview/db" 18 18 + "tangled.sh/tangled.sh/core/appview/pages/markup" 17 19 "tangled.sh/tangled.sh/core/appview/spindleverify" 18 20 "tangled.sh/tangled.sh/core/idresolver" 19 21 "tangled.sh/tangled.sh/core/rbac" ··· 61 63 case tangled.ActorProfileNSID: 62 64 err = i.ingestProfile(e) 63 65 case tangled.SpindleMemberNSID: 64 64 - err = i.ingestSpindleMember(e) 66 66 + err = i.ingestSpindleMember(ctx, e) 65 67 case tangled.SpindleNSID: 66 66 - err = i.ingestSpindle(e) 68 68 + err = i.ingestSpindle(ctx, e) 67 69 case tangled.StringNSID: 68 70 err = i.ingestString(e) 71 71 + case tangled.RepoIssueNSID: 72 72 + err = i.ingestIssue(ctx, e) 73 73 + case tangled.RepoIssueCommentNSID: 74 74 + err = i.ingestIssueComment(e) 69 75 } 70 76 l = i.Logger.With("nsid", e.Commit.Collection) 71 77 } ··· 336 342 return nil 337 343 } 338 344 339 339 - func (i *Ingester) ingestSpindleMember(e *models.Event) error { 345 345 + func (i *Ingester) ingestSpindleMember(ctx context.Context, e *models.Event) error { 340 346 did := e.Did 341 347 var err error 342 348 ··· 359 365 return fmt.Errorf("failed to enforce permissions: %w", err) 360 366 } 361 367 362 362 - memberId, err := i.IdResolver.ResolveIdent(context.Background(), record.Subject) 368 368 + memberId, err := i.IdResolver.ResolveIdent(ctx, record.Subject) 363 369 if err != nil { 364 370 return err 365 371 } ··· 442 448 return nil 443 449 } 444 450 445 445 - func (i *Ingester) ingestSpindle(e *models.Event) error { 451 451 + func (i *Ingester) ingestSpindle(ctx context.Context, e *models.Event) error { 446 452 did := e.Did 447 453 var err error 448 454 ··· 475 481 return err 476 482 } 477 483 478 478 - err = spindleverify.RunVerification(context.Background(), instance, did, i.Config.Core.Dev) 484 484 + err = spindleverify.RunVerification(ctx, instance, did, i.Config.Core.Dev) 479 485 if err != nil { 480 486 l.Error("failed to add spindle to db", "err", err, "instance", instance) 481 487 return err ··· 609 615 610 616 return nil 611 617 } 618 618 + 619 619 + func (i *Ingester) ingestIssue(ctx context.Context, e *models.Event) error { 620 620 + did := e.Did 621 621 + rkey := e.Commit.RKey 622 622 + 623 623 + var err error 624 624 + 625 625 + l := i.Logger.With("handler", "ingestIssue", "nsid", e.Commit.Collection, "did", did, "rkey", rkey) 626 626 + l.Info("ingesting record") 627 627 + 628 628 + ddb, ok := i.Db.Execer.(*db.DB) 629 629 + if !ok { 630 630 + return fmt.Errorf("failed to index issue record, invalid db cast") 631 631 + } 632 632 + 633 633 + switch e.Commit.Operation { 634 634 + case models.CommitOperationCreate: 635 635 + raw := json.RawMessage(e.Commit.Record) 636 636 + record := tangled.RepoIssue{} 637 637 + err = json.Unmarshal(raw, &record) 638 638 + if err != nil { 639 639 + l.Error("invalid record", "err", err) 640 640 + return err 641 641 + } 642 642 + 643 643 + issue := db.IssueFromRecord(did, rkey, record) 644 644 + 645 645 + sanitizer := markup.NewSanitizer() 646 646 + if st := strings.TrimSpace(sanitizer.SanitizeDescription(issue.Title)); st == "" { 647 647 + return fmt.Errorf("title is empty after HTML sanitization") 648 648 + } 649 649 + if sb := strings.TrimSpace(sanitizer.SanitizeDefault(issue.Body)); sb == "" { 650 650 + return fmt.Errorf("body is empty after HTML sanitization") 651 651 + } 652 652 + 653 653 + tx, err := ddb.BeginTx(ctx, nil) 654 654 + if err != nil { 655 655 + l.Error("failed to begin transaction", "err", err) 656 656 + return err 657 657 + } 658 658 + 659 659 + err = db.NewIssue(tx, &issue) 660 660 + if err != nil { 661 661 + l.Error("failed to create issue", "err", err) 662 662 + return err 663 663 + } 664 664 + 665 665 + return nil 666 666 + 667 667 + case models.CommitOperationUpdate: 668 668 + raw := json.RawMessage(e.Commit.Record) 669 669 + record := tangled.RepoIssue{} 670 670 + err = json.Unmarshal(raw, &record) 671 671 + if err != nil { 672 672 + l.Error("invalid record", "err", err) 673 673 + return err 674 674 + } 675 675 + 676 676 + body := "" 677 677 + if record.Body != nil { 678 678 + body = *record.Body 679 679 + } 680 680 + 681 681 + sanitizer := markup.NewSanitizer() 682 682 + if st := strings.TrimSpace(sanitizer.SanitizeDescription(record.Title)); st == "" { 683 683 + return fmt.Errorf("title is empty after HTML sanitization") 684 684 + } 685 685 + if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" { 686 686 + return fmt.Errorf("body is empty after HTML sanitization") 687 687 + } 688 688 + 689 689 + err = db.UpdateIssueByRkey(ddb, did, rkey, record.Title, body) 690 690 + if err != nil { 691 691 + l.Error("failed to update issue", "err", err) 692 692 + return err 693 693 + } 694 694 + 695 695 + return nil 696 696 + 697 697 + case models.CommitOperationDelete: 698 698 + if err := db.DeleteIssueByRkey(ddb, did, rkey); err != nil { 699 699 + l.Error("failed to delete", "err", err) 700 700 + return fmt.Errorf("failed to delete issue record: %w", err) 701 701 + } 702 702 + 703 703 + return nil 704 704 + } 705 705 + 706 706 + return fmt.Errorf("unknown operation: %s", e.Commit.Operation) 707 707 + } 708 708 + 709 709 + func (i *Ingester) ingestIssueComment(e *models.Event) error { 710 710 + did := e.Did 711 711 + rkey := e.Commit.RKey 712 712 + 713 713 + var err error 714 714 + 715 715 + l := i.Logger.With("handler", "ingestIssueComment", "nsid", e.Commit.Collection, "did", did, "rkey", rkey) 716 716 + l.Info("ingesting record") 717 717 + 718 718 + ddb, ok := i.Db.Execer.(*db.DB) 719 719 + if !ok { 720 720 + return fmt.Errorf("failed to index issue comment record, invalid db cast") 721 721 + } 722 722 + 723 723 + switch e.Commit.Operation { 724 724 + case models.CommitOperationCreate: 725 725 + raw := json.RawMessage(e.Commit.Record) 726 726 + record := tangled.RepoIssueComment{} 727 727 + err = json.Unmarshal(raw, &record) 728 728 + if err != nil { 729 729 + l.Error("invalid record", "err", err) 730 730 + return err 731 731 + } 732 732 + 733 733 + comment, err := db.IssueCommentFromRecord(ddb, did, rkey, record) 734 734 + if err != nil { 735 735 + l.Error("failed to parse comment from record", "err", err) 736 736 + return err 737 737 + } 738 738 + 739 739 + sanitizer := markup.NewSanitizer() 740 740 + if sb := strings.TrimSpace(sanitizer.SanitizeDefault(comment.Body)); sb == "" { 741 741 + return fmt.Errorf("body is empty after HTML sanitization") 742 742 + } 743 743 + 744 744 + err = db.NewIssueComment(ddb, &comment) 745 745 + if err != nil { 746 746 + l.Error("failed to create issue comment", "err", err) 747 747 + return err 748 748 + } 749 749 + 750 750 + return nil 751 751 + 752 752 + case models.CommitOperationUpdate: 753 753 + raw := json.RawMessage(e.Commit.Record) 754 754 + record := tangled.RepoIssueComment{} 755 755 + err = json.Unmarshal(raw, &record) 756 756 + if err != nil { 757 757 + l.Error("invalid record", "err", err) 758 758 + return err 759 759 + } 760 760 + 761 761 + sanitizer := markup.NewSanitizer() 762 762 + if sb := strings.TrimSpace(sanitizer.SanitizeDefault(record.Body)); sb == "" { 763 763 + return fmt.Errorf("body is empty after HTML sanitization") 764 764 + } 765 765 + 766 766 + err = db.UpdateCommentByRkey(ddb, did, rkey, record.Body) 767 767 + if err != nil { 768 768 + l.Error("failed to update issue comment", "err", err) 769 769 + return err 770 770 + } 771 771 + 772 772 + return nil 773 773 + 774 774 + case models.CommitOperationDelete: 775 775 + if err := db.DeleteCommentByRkey(ddb, did, rkey); err != nil { 776 776 + l.Error("failed to delete", "err", err) 777 777 + return fmt.Errorf("failed to delete issue comment record: %w", err) 778 778 + } 779 779 + 780 780 + return nil 781 781 + } 782 782 + 783 783 + return fmt.Errorf("unknown operation: %s", e.Commit.Operation) 784 784 + }

+17 -10

appview/issues/issues.go

··· 7 7 "net/http" 8 8 "slices" 9 9 "strconv" 10 10 + "strings" 10 11 "time" 11 12 12 13 comatproto "github.com/bluesky-social/indigo/api/atproto" ··· 20 21 "tangled.sh/tangled.sh/core/appview/notify" 21 22 "tangled.sh/tangled.sh/core/appview/oauth" 22 23 "tangled.sh/tangled.sh/core/appview/pages" 24 24 + "tangled.sh/tangled.sh/core/appview/pages/markup" 23 25 "tangled.sh/tangled.sh/core/appview/pagination" 24 26 "tangled.sh/tangled.sh/core/appview/reporesolver" 25 27 "tangled.sh/tangled.sh/core/idresolver" ··· 276 278 } 277 279 278 280 createdAt := time.Now().Format(time.RFC3339) 279 279 - commentIdInt64 := int64(commentId) 280 281 ownerDid := user.Did 281 282 issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt) 282 283 if err != nil { ··· 300 301 Val: &tangled.RepoIssueComment{ 301 302 Repo: &atUri, 302 303 Issue: issueAt, 303 303 - CommentId: &commentIdInt64, 304 304 Owner: &ownerDid, 305 305 Body: body, 306 306 CreatedAt: createdAt, ··· 449 449 repoAt := record["repo"].(string) 450 450 issueAt := record["issue"].(string) 451 451 createdAt := record["createdAt"].(string) 452 452 - commentIdInt64 := int64(commentIdInt) 453 452 454 453 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 455 454 Collection: tangled.RepoIssueCommentNSID, ··· 460 459 Val: &tangled.RepoIssueComment{ 461 460 Repo: &repoAt, 462 461 Issue: issueAt, 463 463 - CommentId: &commentIdInt64, 464 462 Owner: &comment.OwnerDid, 465 463 Body: newBody, 466 464 CreatedAt: createdAt, ··· 602 600 return 603 601 } 604 602 605 605 - issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page) 603 603 + issues, err := db.GetIssuesPaginated(rp.db, f.RepoAt(), isOpen, page) 606 604 if err != nil { 607 605 log.Println("failed to get issues", err) 608 606 rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") ··· 642 640 return 643 641 } 644 642 643 643 + sanitizer := markup.NewSanitizer() 644 644 + if st := strings.TrimSpace(sanitizer.SanitizeDescription(title)); st == "" { 645 645 + rp.pages.Notice(w, "issues", "Title is empty after HTML sanitization") 646 646 + return 647 647 + } 648 648 + if sb := strings.TrimSpace(sanitizer.SanitizeDefault(body)); sb == "" { 649 649 + rp.pages.Notice(w, "issues", "Body is empty after HTML sanitization") 650 650 + return 651 651 + } 652 652 + 645 653 tx, err := rp.db.BeginTx(r.Context(), nil) 646 654 if err != nil { 647 655 rp.pages.Notice(w, "issues", "Failed to create issue, try again later") ··· 675 683 Rkey: issue.Rkey, 676 684 Record: &lexutil.LexiconTypeDecoder{ 677 685 Val: &tangled.RepoIssue{ 678 678 - Repo: atUri, 679 679 - Title: title, 680 680 - Body: &body, 681 681 - Owner: user.Did, 682 682 - IssueId: int64(issue.IssueId), 686 686 + Repo: atUri, 687 687 + Title: title, 688 688 + Body: &body, 689 689 + Owner: user.Did, 683 690 }, 684 691 }, 685 692 })

+6 -1

appview/pages/funcmap.go

··· 206 206 } 207 207 return v.Slice(0, min(n, v.Len())).Interface() 208 208 }, 209 209 - 210 209 "markdown": func(text string) template.HTML { 211 210 p.rctx.RendererType = markup.RendererTypeDefault 212 211 htmlString := p.rctx.RenderMarkdown(text) 213 212 sanitized := p.rctx.SanitizeDefault(htmlString) 213 213 + return template.HTML(sanitized) 214 214 + }, 215 215 + "description": func(text string) template.HTML { 216 216 + p.rctx.RendererType = markup.RendererTypeDefault 217 217 + htmlString := p.rctx.RenderMarkdown(text) 218 218 + sanitized := p.rctx.SanitizeDescription(htmlString) 214 219 return template.HTML(sanitized) 215 220 }, 216 221 "isNil": func(t any) bool {

+5 -1

appview/pages/markup/markdown.go

··· 161 161 } 162 162 163 163 func (rctx *RenderContext) SanitizeDefault(html string) string { 164 164 - return rctx.Sanitizer.defaultPolicy.Sanitize(html) 164 164 + return rctx.Sanitizer.SanitizeDefault(html) 165 165 + } 166 166 + 167 167 + func (rctx *RenderContext) SanitizeDescription(html string) string { 168 168 + return rctx.Sanitizer.SanitizeDescription(html) 165 169 } 166 170 167 171 type MarkdownTransformer struct {

+27 -2

appview/pages/markup/sanitizer.go

··· 11 11 ) 12 12 13 13 type Sanitizer struct { 14 14 - defaultPolicy *bluemonday.Policy 14 14 + defaultPolicy *bluemonday.Policy 15 15 + descriptionPolicy *bluemonday.Policy 15 16 } 16 17 17 18 func NewSanitizer() Sanitizer { 18 19 return Sanitizer{ 19 19 - defaultPolicy: defaultPolicy(), 20 20 + defaultPolicy: defaultPolicy(), 21 21 + descriptionPolicy: descriptionPolicy(), 20 22 } 23 23 + } 24 24 + 25 25 + func (s *Sanitizer) SanitizeDefault(html string) string { 26 26 + return s.defaultPolicy.Sanitize(html) 27 27 + } 28 28 + func (s *Sanitizer) SanitizeDescription(html string) string { 29 29 + return s.descriptionPolicy.Sanitize(html) 21 30 } 22 31 23 32 func defaultPolicy() *bluemonday.Policy { ··· 90 99 91 100 return policy 92 101 } 102 102 + 103 103 + func descriptionPolicy() *bluemonday.Policy { 104 104 + policy := bluemonday.NewPolicy() 105 105 + policy.AllowStandardURLs() 106 106 + 107 107 + // allow italics and bold. 108 108 + policy.AllowElements("i", "b", "em", "strong") 109 109 + 110 110 + // allow code. 111 111 + policy.AllowElements("code") 112 112 + 113 113 + // allow links 114 114 + policy.AllowAttrs("href", "target", "rel").OnElements("a") 115 115 + 116 116 + return policy 117 117 + }

+33 -25

appview/pages/pages.go

··· 299 299 type TimelineParams struct { 300 300 LoggedInUser *oauth.User 301 301 Timeline []db.TimelineEvent 302 302 + Repos []db.Repo 302 303 } 303 304 304 305 func (p *Pages) Timeline(w io.Writer, params TimelineParams) error { 305 305 - return p.execute("timeline", w, params) 306 306 + return p.execute("timeline/timeline", w, params) 306 307 } 307 308 308 309 type SettingsParams struct { ··· 520 521 } 521 522 522 523 p.rctx.RepoInfo = params.RepoInfo 524 524 + p.rctx.RepoInfo.Ref = params.Ref 523 525 p.rctx.RendererType = markup.RendererTypeRepoMarkdown 524 526 525 527 if params.ReadmeFileName != "" { ··· 673 675 } 674 676 } 675 677 676 676 - if params.Lines < 5000 { 677 677 - c := params.Contents 678 678 - formatter := chromahtml.New( 679 679 - chromahtml.InlineCode(false), 680 680 - chromahtml.WithLineNumbers(true), 681 681 - chromahtml.WithLinkableLineNumbers(true, "L"), 682 682 - chromahtml.Standalone(false), 683 683 - chromahtml.WithClasses(true), 684 684 - ) 678 678 + c := params.Contents 679 679 + formatter := chromahtml.New( 680 680 + chromahtml.InlineCode(false), 681 681 + chromahtml.WithLineNumbers(true), 682 682 + chromahtml.WithLinkableLineNumbers(true, "L"), 683 683 + chromahtml.Standalone(false), 684 684 + chromahtml.WithClasses(true), 685 685 + ) 685 686 686 686 - lexer := lexers.Get(filepath.Base(params.Path)) 687 687 - if lexer == nil { 688 688 - lexer = lexers.Fallback 689 689 - } 687 687 + lexer := lexers.Get(filepath.Base(params.Path)) 688 688 + if lexer == nil { 689 689 + lexer = lexers.Fallback 690 690 + } 690 691 691 691 - iterator, err := lexer.Tokenise(nil, c) 692 692 - if err != nil { 693 693 - return fmt.Errorf("chroma tokenize: %w", err) 694 694 - } 695 695 - 696 696 - var code bytes.Buffer 697 697 - err = formatter.Format(&code, style, iterator) 698 698 - if err != nil { 699 699 - return fmt.Errorf("chroma format: %w", err) 700 700 - } 692 692 + iterator, err := lexer.Tokenise(nil, c) 693 693 + if err != nil { 694 694 + return fmt.Errorf("chroma tokenize: %w", err) 695 695 + } 701 696 702 702 - params.Contents = code.String() 697 697 + var code bytes.Buffer 698 698 + err = formatter.Format(&code, style, iterator) 699 699 + if err != nil { 700 700 + return fmt.Errorf("chroma format: %w", err) 703 701 } 704 702 703 703 + params.Contents = code.String() 705 704 params.Active = "overview" 706 705 return p.executeRepo("repo/blob", w, params) 707 706 } ··· 1158 1157 1159 1158 func (p *Pages) StringsDashboard(w io.Writer, params StringsDashboardParams) error { 1160 1159 return p.execute("strings/dashboard", w, params) 1160 1160 + } 1161 1161 + 1162 1162 + type StringTimelineParams struct { 1163 1163 + LoggedInUser *oauth.User 1164 1164 + Strings []db.String 1165 1165 + } 1166 1166 + 1167 1167 + func (p *Pages) StringsTimeline(w io.Writer, params StringTimelineParams) error { 1168 1168 + return p.execute("strings/timeline", w, params) 1161 1169 } 1162 1170 1163 1171 type SingleStringParams struct {

+15 -20

appview/pages/templates/layouts/repobase.html

··· 20 20 </div> 21 21 22 22 <div class="flex items-center gap-2 z-auto"> 23 23 + <a 24 24 + class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group" 25 25 + href="/{{ .RepoInfo.FullName }}/feed.atom" 26 26 + > 27 27 + {{ i "rss" "size-4" }} 28 28 + </a> 23 29 {{ template "repo/fragments/repoStar" .RepoInfo }} 24 24 - {{ if .RepoInfo.DisableFork }} 25 25 - <button 26 26 - class="btn text-sm no-underline hover:no-underline flex items-center gap-2 disabled:opacity-50 disabled:cursor-not-allowed" 27 27 - disabled 28 28 - title="Empty repositories cannot be forked" 29 29 - > 30 30 - {{ i "git-fork" "w-4 h-4" }} 31 31 - fork 32 32 - </button> 33 33 - {{ else }} 34 34 - <a 35 35 - class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group" 36 36 - hx-boost="true" 37 37 - href="/{{ .RepoInfo.FullName }}/fork" 38 38 - > 39 39 - {{ i "git-fork" "w-4 h-4" }} 40 40 - fork 41 41 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 42 42 - </a> 43 43 - {{ end }} 30 30 + <a 31 31 + class="btn text-sm no-underline hover:no-underline flex items-center gap-2 group" 32 32 + hx-boost="true" 33 33 + href="/{{ .RepoInfo.FullName }}/fork" 34 34 + > 35 35 + {{ i "git-fork" "w-4 h-4" }} 36 36 + fork 37 37 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 38 38 + </a> 44 39 </div> 45 40 </div> 46 41 {{ template "repo/fragments/repoDescription" . }}

+1 -1

appview/pages/templates/repo/fragments/repoDescription.html

··· 1 1 {{ define "repo/fragments/repoDescription" }} 2 2 <span id="repo-description" class="flex flex-wrap items-center gap-2 text-sm" hx-target="this" hx-swap="outerHTML"> 3 3 {{ if .RepoInfo.Description }} 4 4 - {{ .RepoInfo.Description }} 4 4 + {{ .RepoInfo.Description | description }} 5 5 {{ else }} 6 6 <span class="italic">this repo has no description</span> 7 7 {{ end }}

+1 -1

appview/pages/templates/repo/issues/issue.html

··· 11 11 {{ define "repoContent" }} 12 12 <header class="pb-4"> 13 13 <h1 class="text-2xl"> 14 14 - {{ .Issue.Title }} 14 14 + {{ .Issue.Title | description }} 15 15 <span class="text-gray-500 dark:text-gray-400">#{{ .Issue.IssueId }}</span> 16 16 </h1> 17 17 </header>

+1 -1

appview/pages/templates/repo/issues/issues.html

··· 45 45 href="/{{ $.RepoInfo.FullName }}/issues/{{ .IssueId }}" 46 46 class="no-underline hover:underline" 47 47 > 48 48 - {{ .Title }} 48 48 + {{ .Title | description }} 49 49 <span class="text-gray-500">#{{ .IssueId }}</span> 50 50 </a> 51 51 </div>

+1 -1

appview/pages/templates/repo/pulls/fragments/pullHeader.html

··· 1 1 {{ define "repo/pulls/fragments/pullHeader" }} 2 2 <header class="pb-4"> 3 3 <h1 class="text-2xl dark:text-white"> 4 4 - {{ .Pull.Title }} 4 4 + {{ .Pull.Title | description }} 5 5 <span class="text-gray-500 dark:text-gray-400">#{{ .Pull.PullId }}</span> 6 6 </h1> 7 7 </header>

+1 -1

appview/pages/templates/repo/pulls/fragments/summarizedPullHeader.html

··· 9 9 </div> 10 10 <span class="truncate text-sm text-gray-800 dark:text-gray-200"> 11 11 <span class="text-gray-500 dark:text-gray-400">#{{ .PullId }}</span> 12 12 - {{ .Title }} 12 12 + {{ .Title | description }} 13 13 </span> 14 14 </div> 15 15

+1 -1

appview/pages/templates/repo/pulls/pull.html

··· 122 122 {{ end }} 123 123 </div> 124 124 <div class="flex items-center"> 125 125 - <span>{{ .Title }}</span> 125 125 + <span>{{ .Title | description }}</span> 126 126 {{ if gt (len .Body) 0 }} 127 127 <button 128 128 class="py-1/2 px-1 mx-2 bg-gray-200 hover:bg-gray-400 rounded dark:bg-gray-700 dark:hover:bg-gray-600"

+1 -1

appview/pages/templates/repo/pulls/pulls.html

··· 50 50 <div class="px-6 py-4 z-5"> 51 51 <div class="pb-2"> 52 52 <a href="/{{ $.RepoInfo.FullName }}/pulls/{{ .PullId }}" class="dark:text-white"> 53 53 - {{ .Title }} 53 53 + {{ .Title | description }} 54 54 <span class="text-gray-500 dark:text-gray-400">#{{ .PullId }}</span> 55 55 </a> 56 56 </div>

+3 -2

appview/pages/templates/strings/fragments/form.html

··· 13 13 type="text" 14 14 id="filename" 15 15 name="filename" 16 16 - placeholder="Filename with extension" 16 16 + placeholder="Filename" 17 17 required 18 18 value="{{ .String.Filename }}" 19 19 class="md:max-w-64 dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 px-3 py-2 border rounded" ··· 31 31 name="content" 32 32 id="content-textarea" 33 33 wrap="off" 34 34 - class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400" 34 34 + class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400 font-mono" 35 35 rows="20" 36 36 + spellcheck="false" 36 37 placeholder="Paste your string here!" 37 38 required>{{ .String.Contents }}</textarea> 38 39 <div class="flex justify-between items-center">

+2 -2

appview/pages/templates/strings/string.html

··· 35 35 title="Delete string" 36 36 hx-delete="/strings/{{ .String.Did }}/{{ .String.Rkey }}/" 37 37 hx-swap="none" 38 38 - hx-confirm="Are you sure you want to delete the gist `{{ .String.Filename }}`?" 38 38 + hx-confirm="Are you sure you want to delete the string `{{ .String.Filename }}`?" 39 39 > 40 40 {{ i "trash-2" "size-4" }} 41 41 <span class="hidden md:inline">delete</span> ··· 77 77 {{ end }} 78 78 </div> 79 79 </div> 80 80 - <div class="overflow-auto relative"> 80 80 + <div class="overflow-x-auto overflow-y-hidden relative"> 81 81 {{ if .ShowRendered }} 82 82 <div id="blob-contents" class="prose dark:prose-invert">{{ .RenderedContents }}</div> 83 83 {{ else }}

+65

appview/pages/templates/strings/timeline.html

··· 1 1 + {{ define "title" }} all strings {{ end }} 2 2 + 3 3 + {{ define "topbar" }} 4 4 + {{ template "layouts/topbar" $ }} 5 5 + {{ end }} 6 6 + 7 7 + {{ define "content" }} 8 8 + {{ block "timeline" $ }}{{ end }} 9 9 + {{ end }} 10 10 + 11 11 + {{ define "timeline" }} 12 12 + <div> 13 13 + <div class="p-6"> 14 14 + <p class="text-xl font-bold dark:text-white">All strings</p> 15 15 + </div> 16 16 + 17 17 + <div class="flex flex-col gap-4"> 18 18 + {{ range $i, $s := .Strings }} 19 19 + <div class="relative"> 20 20 + {{ if ne $i 0 }} 21 21 + <div class="absolute left-8 -top-4 w-px h-4 bg-gray-300 dark:bg-gray-600"></div> 22 22 + {{ end }} 23 23 + <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm"> 24 24 + {{ template "stringCard" $s }} 25 25 + </div> 26 26 + </div> 27 27 + {{ end }} 28 28 + </div> 29 29 + </div> 30 30 + {{ end }} 31 31 + 32 32 + {{ define "stringCard" }} 33 33 + <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800"> 34 34 + <div class="font-medium dark:text-white flex gap-2 items-center"> 35 35 + <a href="/strings/{{ resolve .Did.String }}/{{ .Rkey }}">{{ .Filename }}</a> 36 36 + </div> 37 37 + {{ with .Description }} 38 38 + <div class="text-gray-600 dark:text-gray-300 text-sm"> 39 39 + {{ . }} 40 40 + </div> 41 41 + {{ end }} 42 42 + 43 43 + {{ template "stringCardInfo" . }} 44 44 + </div> 45 45 + {{ end }} 46 46 + 47 47 + {{ define "stringCardInfo" }} 48 48 + {{ $stat := .Stats }} 49 49 + {{ $resolved := resolve .Did.String }} 50 50 + <div class="text-gray-400 pt-4 text-sm font-mono inline-flex items-center gap-2 mt-auto"> 51 51 + <a href="/strings/{{ $resolved }}" class="flex items-center"> 52 52 + {{ template "user/fragments/picHandle" $resolved }} 53 53 + </a> 54 54 + <span class="select-none [&:before]:content-['·']"></span> 55 55 + <span>{{ $stat.LineCount }} line{{if ne $stat.LineCount 1}}s{{end}}</span> 56 56 + <span class="select-none [&:before]:content-['·']"></span> 57 57 + {{ with .Edited }} 58 58 + <span>edited {{ template "repo/fragments/shortTimeAgo" . }}</span> 59 59 + {{ else }} 60 60 + {{ template "repo/fragments/shortTimeAgo" .Created }} 61 61 + {{ end }} 62 62 + </div> 63 63 + {{ end }} 64 64 + 65 65 +

+183

appview/pages/templates/timeline/timeline.html

··· 1 1 + {{ define "title" }}timeline{{ end }} 2 2 + 3 3 + {{ define "extrameta" }} 4 4 + <meta property="og:title" content="timeline · tangled" /> 5 5 + <meta property="og:type" content="object" /> 6 6 + <meta property="og:url" content="https://tangled.sh" /> 7 7 + <meta property="og:description" content="tightly-knit social coding" /> 8 8 + {{ end }} 9 9 + 10 10 + {{ define "content" }} 11 11 + {{ if .LoggedInUser }} 12 12 + {{ else }} 13 13 + {{ block "hero" $ }}{{ end }} 14 14 + {{ end }} 15 15 + 16 16 + {{ block "trending" $ }}{{ end }} 17 17 + {{ block "timeline" $ }}{{ end }} 18 18 + {{ end }} 19 19 + 20 20 + {{ define "hero" }} 21 21 + <div class="flex flex-col text-black dark:text-white p-6 gap-6 max-w-xl"> 22 22 + <div class="font-bold text-4xl">tightly-knit<br>social coding.</div> 23 23 + 24 24 + <p class="text-lg"> 25 25 + tangled is new social-enabled git collaboration platform built on <a class="underline" href="https://atproto.com/">atproto</a>. 26 26 + </p> 27 27 + <p class="text-lg"> 28 28 + we envision a place where developers have complete ownership of their 29 29 + code, open source communities can freely self-govern and most 30 30 + importantly, coding can be social and fun again. 31 31 + </p> 32 32 + 33 33 + <div class="flex gap-6 items-center"> 34 34 + <a href="/signup" class="no-underline hover:no-underline "> 35 35 + <button class="btn-create flex gap-2 px-4 items-center"> 36 36 + join now {{ i "arrow-right" "size-4" }} 37 37 + </button> 38 38 + </a> 39 39 + </div> 40 40 + </div> 41 41 + {{ end }} 42 42 + 43 43 + {{ define "trending" }} 44 44 + <div class="w-full md:mx-0 py-4"> 45 45 + <div class="px-6 pb-4"> 46 46 + <h3 class="text-xl font-bold dark:text-white flex items-center gap-2"> 47 47 + Trending 48 48 + {{ i "trending-up" "size-4 flex-shrink-0" }} 49 49 + </h3> 50 50 + </div> 51 51 + <div class="flex gap-4 overflow-x-auto scrollbar-hide items-stretch"> 52 52 + {{ range $index, $repo := .Repos }} 53 53 + <div class="flex-none h-full border border-gray-200 dark:border-gray-700 rounded-sm w-96"> 54 54 + {{ template "user/fragments/repoCard" (list $ $repo true) }} 55 55 + </div> 56 56 + {{ else }} 57 57 + <div class="py-8 px-6 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-sm"> 58 58 + <div class="text-sm text-gray-500 dark:text-gray-400 text-center"> 59 59 + No trending repositories this week 60 60 + </div> 61 61 + </div> 62 62 + {{ end }} 63 63 + </div> 64 64 + </div> 65 65 + {{ end }} 66 66 + 67 67 + {{ define "timeline" }} 68 68 + <div class="py-4"> 69 69 + <div class="px-6 pb-4"> 70 70 + <p class="text-xl font-bold dark:text-white">Timeline</p> 71 71 + </div> 72 72 + 73 73 + <div class="flex flex-col gap-4"> 74 74 + {{ range $i, $e := .Timeline }} 75 75 + <div class="relative"> 76 76 + {{ if ne $i 0 }} 77 77 + <div class="absolute left-8 -top-4 w-px h-4 bg-gray-300 dark:bg-gray-600"></div> 78 78 + {{ end }} 79 79 + {{ with $e }} 80 80 + <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm"> 81 81 + {{ if .Repo }} 82 82 + {{ block "repoEvent" (list $ .Repo .Source) }} {{ end }} 83 83 + {{ else if .Star }} 84 84 + {{ block "starEvent" (list $ .Star) }} {{ end }} 85 85 + {{ else if .Follow }} 86 86 + {{ block "followEvent" (list $ .Follow .Profile .FollowStats) }} {{ end }} 87 87 + {{ end }} 88 88 + </div> 89 89 + {{ end }} 90 90 + </div> 91 91 + {{ end }} 92 92 + </div> 93 93 + </div> 94 94 + {{ end }} 95 95 + 96 96 + {{ define "repoEvent" }} 97 97 + {{ $root := index . 0 }} 98 98 + {{ $repo := index . 1 }} 99 99 + {{ $source := index . 2 }} 100 100 + {{ $userHandle := resolve $repo.Did }} 101 101 + <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 102 102 + {{ template "user/fragments/picHandleLink" $repo.Did }} 103 103 + {{ with $source }} 104 104 + {{ $sourceDid := resolve .Did }} 105 105 + forked 106 106 + <a href="/{{ $sourceDid }}/{{ .Name }}"class="no-underline hover:underline"> 107 107 + {{ $sourceDid }}/{{ .Name }} 108 108 + </a> 109 109 + to 110 110 + <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline">{{ $repo.Name }}</a> 111 111 + {{ else }} 112 112 + created 113 113 + <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline"> 114 114 + {{ $repo.Name }} 115 115 + </a> 116 116 + {{ end }} 117 117 + <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $repo.Created }}</span> 118 118 + </div> 119 119 + {{ with $repo }} 120 120 + {{ template "user/fragments/repoCard" (list $root . true) }} 121 121 + {{ end }} 122 122 + {{ end }} 123 123 + 124 124 + {{ define "starEvent" }} 125 125 + {{ $root := index . 0 }} 126 126 + {{ $star := index . 1 }} 127 127 + {{ with $star }} 128 128 + {{ $starrerHandle := resolve .StarredByDid }} 129 129 + {{ $repoOwnerHandle := resolve .Repo.Did }} 130 130 + <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 131 131 + {{ template "user/fragments/picHandleLink" $starrerHandle }} 132 132 + starred 133 133 + <a href="/{{ $repoOwnerHandle }}/{{ .Repo.Name }}" class="no-underline hover:underline"> 134 134 + {{ $repoOwnerHandle | truncateAt30 }}/{{ .Repo.Name }} 135 135 + </a> 136 136 + <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" .Created }}</span> 137 137 + </div> 138 138 + {{ with .Repo }} 139 139 + {{ template "user/fragments/repoCard" (list $root . true) }} 140 140 + {{ end }} 141 141 + {{ end }} 142 142 + {{ end }} 143 143 + 144 144 + 145 145 + {{ define "followEvent" }} 146 146 + {{ $root := index . 0 }} 147 147 + {{ $follow := index . 1 }} 148 148 + {{ $profile := index . 2 }} 149 149 + {{ $stat := index . 3 }} 150 150 + 151 151 + {{ $userHandle := resolve $follow.UserDid }} 152 152 + {{ $subjectHandle := resolve $follow.SubjectDid }} 153 153 + <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 154 154 + {{ template "user/fragments/picHandleLink" $userHandle }} 155 155 + followed 156 156 + {{ template "user/fragments/picHandleLink" $subjectHandle }} 157 157 + <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $follow.FollowedAt }}</span> 158 158 + </div> 159 159 + <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4"> 160 160 + <div class="flex-shrink-0 max-h-full w-24 h-24"> 161 161 + <img class="object-cover rounded-full p-2" src="{{ fullAvatar $subjectHandle }}" /> 162 162 + </div> 163 163 + 164 164 + <div class="flex-1 min-h-0 justify-around flex flex-col"> 165 165 + <a href="/{{ $subjectHandle }}"> 166 166 + <span class="font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap max-w-full">{{ $subjectHandle | truncateAt30 }}</span> 167 167 + </a> 168 168 + {{ with $profile }} 169 169 + {{ with .Description }} 170 170 + <p class="text-sm pb-2 md:pb-2">{{.}}</p> 171 171 + {{ end }} 172 172 + {{ end }} 173 173 + {{ with $stat }} 174 174 + <div class="text-sm flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm"> 175 175 + <span class="flex-shrink-0">{{ i "users" "size-4" }}</span> 176 176 + <span id="followers">{{ .Followers }} followers</span> 177 177 + <span class="select-none after:content-['·']"></span> 178 178 + <span id="following">{{ .Following }} following</span> 179 179 + </div> 180 180 + {{ end }} 181 181 + </div> 182 182 + </div> 183 183 + {{ end }}

-162

appview/pages/templates/timeline.html

··· 1 1 - {{ define "title" }}timeline{{ end }} 2 2 - 3 3 - {{ define "extrameta" }} 4 4 - <meta property="og:title" content="timeline · tangled" /> 5 5 - <meta property="og:type" content="object" /> 6 6 - <meta property="og:url" content="https://tangled.sh" /> 7 7 - <meta property="og:description" content="see what's tangling" /> 8 8 - {{ end }} 9 9 - 10 10 - {{ define "topbar" }} 11 11 - {{ template "layouts/topbar" $ }} 12 12 - {{ end }} 13 13 - 14 14 - {{ define "content" }} 15 15 - {{ with .LoggedInUser }} 16 16 - {{ block "timeline" $ }}{{ end }} 17 17 - {{ else }} 18 18 - {{ block "hero" $ }}{{ end }} 19 19 - {{ block "timeline" $ }}{{ end }} 20 20 - {{ end }} 21 21 - {{ end }} 22 22 - 23 23 - {{ define "hero" }} 24 24 - <div class="flex flex-col text-black dark:text-white p-6 gap-6 max-w-xl"> 25 25 - <div class="font-bold text-4xl">tightly-knit<br>social coding.</div> 26 26 - 27 27 - <p class="text-lg"> 28 28 - tangled is new social-enabled git collaboration platform built on <a class="underline" href="https://atproto.com/">atproto</a>. 29 29 - </p> 30 30 - <p class="text-lg"> 31 31 - we envision a place where developers have complete ownership of their 32 32 - code, open source communities can freely self-govern and most 33 33 - importantly, coding can be social and fun again. 34 34 - </p> 35 35 - 36 36 - <div class="flex gap-6 items-center"> 37 37 - <a href="/signup" class="no-underline hover:no-underline "> 38 38 - <button class="btn-create flex gap-2 px-4 items-center"> 39 39 - join now {{ i "arrow-right" "size-4" }} 40 40 - </button> 41 41 - </a> 42 42 - </div> 43 43 - </div> 44 44 - {{ end }} 45 45 - 46 46 - {{ define "timeline" }} 47 47 - <div> 48 48 - <div class="p-6"> 49 49 - <p class="text-xl font-bold dark:text-white">Timeline</p> 50 50 - </div> 51 51 - 52 52 - <div class="flex flex-col gap-4"> 53 53 - {{ range $i, $e := .Timeline }} 54 54 - <div class="relative"> 55 55 - {{ if ne $i 0 }} 56 56 - <div class="absolute left-8 -top-4 w-px h-4 bg-gray-300 dark:bg-gray-600"></div> 57 57 - {{ end }} 58 58 - {{ with $e }} 59 59 - <div class="flex flex-col divide-y divide-gray-200 dark:divide-gray-700 border border-gray-200 dark:border-gray-700 rounded-sm"> 60 60 - {{ if .Repo }} 61 61 - {{ block "repoEvent" (list $ .Repo .Source) }} {{ end }} 62 62 - {{ else if .Star }} 63 63 - {{ block "starEvent" (list $ .Star) }} {{ end }} 64 64 - {{ else if .Follow }} 65 65 - {{ block "followEvent" (list $ .Follow .Profile .FollowStats) }} {{ end }} 66 66 - {{ end }} 67 67 - </div> 68 68 - {{ end }} 69 69 - </div> 70 70 - {{ end }} 71 71 - </div> 72 72 - </div> 73 73 - {{ end }} 74 74 - 75 75 - {{ define "repoEvent" }} 76 76 - {{ $root := index . 0 }} 77 77 - {{ $repo := index . 1 }} 78 78 - {{ $source := index . 2 }} 79 79 - {{ $userHandle := resolve $repo.Did }} 80 80 - <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 81 81 - {{ template "user/fragments/picHandleLink" $repo.Did }} 82 82 - {{ with $source }} 83 83 - {{ $sourceDid := resolve .Did }} 84 84 - forked 85 85 - <a href="/{{ $sourceDid }}/{{ .Name }}"class="no-underline hover:underline"> 86 86 - {{ $sourceDid }}/{{ .Name }} 87 87 - </a> 88 88 - to 89 89 - <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline">{{ $repo.Name }}</a> 90 90 - {{ else }} 91 91 - created 92 92 - <a href="/{{ $userHandle }}/{{ $repo.Name }}" class="no-underline hover:underline"> 93 93 - {{ $repo.Name }} 94 94 - </a> 95 95 - {{ end }} 96 96 - <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $repo.Created }}</span> 97 97 - </div> 98 98 - {{ with $repo }} 99 99 - {{ template "user/fragments/repoCard" (list $root . true) }} 100 100 - {{ end }} 101 101 - {{ end }} 102 102 - 103 103 - {{ define "starEvent" }} 104 104 - {{ $root := index . 0 }} 105 105 - {{ $star := index . 1 }} 106 106 - {{ with $star }} 107 107 - {{ $starrerHandle := resolve .StarredByDid }} 108 108 - {{ $repoOwnerHandle := resolve .Repo.Did }} 109 109 - <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 110 110 - {{ template "user/fragments/picHandleLink" $starrerHandle }} 111 111 - starred 112 112 - <a href="/{{ $repoOwnerHandle }}/{{ .Repo.Name }}" class="no-underline hover:underline"> 113 113 - {{ $repoOwnerHandle | truncateAt30 }}/{{ .Repo.Name }} 114 114 - </a> 115 115 - <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" .Created }}</span> 116 116 - </div> 117 117 - {{ with .Repo }} 118 118 - {{ template "user/fragments/repoCard" (list $root . true) }} 119 119 - {{ end }} 120 120 - {{ end }} 121 121 - {{ end }} 122 122 - 123 123 - 124 124 - {{ define "followEvent" }} 125 125 - {{ $root := index . 0 }} 126 126 - {{ $follow := index . 1 }} 127 127 - {{ $profile := index . 2 }} 128 128 - {{ $stat := index . 3 }} 129 129 - 130 130 - {{ $userHandle := resolve $follow.UserDid }} 131 131 - {{ $subjectHandle := resolve $follow.SubjectDid }} 132 132 - <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm"> 133 133 - {{ template "user/fragments/picHandleLink" $userHandle }} 134 134 - followed 135 135 - {{ template "user/fragments/picHandleLink" $subjectHandle }} 136 136 - <span class="text-gray-700 dark:text-gray-400 text-xs">{{ template "repo/fragments/time" $follow.FollowedAt }}</span> 137 137 - </div> 138 138 - <div class="py-4 px-6 drop-shadow-sm rounded bg-white dark:bg-gray-800 flex items-center gap-4"> 139 139 - <div class="flex-shrink-0 max-h-full w-24 h-24"> 140 140 - <img class="object-cover rounded-full p-2" src="{{ fullAvatar $subjectHandle }}" /> 141 141 - </div> 142 142 - 143 143 - <div class="flex-1 min-h-0 justify-around flex flex-col"> 144 144 - <a href="/{{ $subjectHandle }}"> 145 145 - <span class="font-bold dark:text-white overflow-hidden text-ellipsis whitespace-nowrap max-w-full">{{ $subjectHandle | truncateAt30 }}</span> 146 146 - </a> 147 147 - {{ with $profile }} 148 148 - {{ with .Description }} 149 149 - <p class="text-sm pb-2 md:pb-2">{{.}}</p> 150 150 - {{ end }} 151 151 - {{ end }} 152 152 - {{ with $stat }} 153 153 - <div class="text-sm flex items-center gap-2 my-2 overflow-hidden text-ellipsis whitespace-nowrap max-w-full text-sm"> 154 154 - <span class="flex-shrink-0">{{ i "users" "size-4" }}</span> 155 155 - <span id="followers">{{ .Followers }} followers</span> 156 156 - <span class="select-none after:content-['·']"></span> 157 157 - <span id="following">{{ .Following }} following</span> 158 158 - </div> 159 159 - {{ end }} 160 160 - </div> 161 161 - </div> 162 162 - {{ end }}

+5 -5

appview/pages/templates/user/fragments/repoCard.html

··· 4 4 {{ $fullName := index . 2 }} 5 5 6 6 {{ with $repo }} 7 7 - <div class="py-4 px-6 gap-2 flex flex-col drop-shadow-sm rounded bg-white dark:bg-gray-800"> 7 7 + <div class="py-4 px-6 gap-1 flex flex-col drop-shadow-sm rounded bg-white dark:bg-gray-800 min-h-32"> 8 8 <div class="font-medium dark:text-white flex items-center"> 9 9 {{ if .Source }} 10 10 {{ i "git-fork" "w-4 h-4 mr-1.5 shrink-0" }} ··· 14 14 15 15 {{ $repoOwner := resolve .Did }} 16 16 {{- if $fullName -}} 17 17 - <a href="/{{ $repoOwner }}/{{ .Name }}">{{ $repoOwner }}/{{ .Name }}</a> 17 17 + <a href="/{{ $repoOwner }}/{{ .Name }}" class="truncate">{{ $repoOwner }}/{{ .Name }}</a> 18 18 {{- else -}} 19 19 - <a href="/{{ $repoOwner }}/{{ .Name }}">{{ .Name }}</a> 19 19 + <a href="/{{ $repoOwner }}/{{ .Name }}" class="truncate">{{ .Name }}</a> 20 20 {{- end -}} 21 21 </div> 22 22 {{ with .Description }} 23 23 - <div class="text-gray-600 dark:text-gray-300 text-sm"> 24 24 - {{ . }} 23 23 + <div class="text-gray-600 dark:text-gray-300 text-sm line-clamp-2"> 24 24 + {{ . | description }} 25 25 </div> 26 26 {{ end }} 27 27

+6

appview/pulls/pulls.go

··· 19 19 "tangled.sh/tangled.sh/core/appview/notify" 20 20 "tangled.sh/tangled.sh/core/appview/oauth" 21 21 "tangled.sh/tangled.sh/core/appview/pages" 22 22 + "tangled.sh/tangled.sh/core/appview/pages/markup" 22 23 "tangled.sh/tangled.sh/core/appview/reporesolver" 23 24 "tangled.sh/tangled.sh/core/idresolver" 24 25 "tangled.sh/tangled.sh/core/knotclient" ··· 737 738 if isPatchBased && !patchutil.IsFormatPatch(patch) { 738 739 if title == "" { 739 740 s.pages.Notice(w, "pull", "Title is required for git-diff patches.") 741 741 + return 742 742 + } 743 743 + sanitizer := markup.NewSanitizer() 744 744 + if st := strings.TrimSpace(sanitizer.SanitizeDescription(title)); (st) == "" { 745 745 + s.pages.Notice(w, "pull", "Title is empty after HTML sanitization") 740 746 return 741 747 } 742 748 }

+165

appview/repo/feed.go

··· 1 1 + package repo 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "fmt" 6 6 + "log" 7 7 + "net/http" 8 8 + "slices" 9 9 + "time" 10 10 + 11 11 + "tangled.sh/tangled.sh/core/appview/db" 12 12 + "tangled.sh/tangled.sh/core/appview/reporesolver" 13 13 + 14 14 + "github.com/bluesky-social/indigo/atproto/syntax" 15 15 + "github.com/gorilla/feeds" 16 16 + ) 17 17 + 18 18 + func (rp *Repo) getRepoFeed(ctx context.Context, f *reporesolver.ResolvedRepo) (*feeds.Feed, error) { 19 19 + const feedLimitPerType = 100 20 20 + 21 21 + pulls, err := db.GetPullsWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt())) 22 22 + if err != nil { 23 23 + return nil, err 24 24 + } 25 25 + 26 26 + issues, err := db.GetIssuesWithLimit(rp.db, feedLimitPerType, db.FilterEq("repo_at", f.RepoAt())) 27 27 + if err != nil { 28 28 + return nil, err 29 29 + } 30 30 + 31 31 + feed := &feeds.Feed{ 32 32 + Title: fmt.Sprintf("activity feed for %s", f.OwnerSlashRepo()), 33 33 + Link: &feeds.Link{Href: fmt.Sprintf("%s/%s", rp.config.Core.AppviewHost, f.OwnerSlashRepo()), Type: "text/html", Rel: "alternate"}, 34 34 + Items: make([]*feeds.Item, 0), 35 35 + Updated: time.UnixMilli(0), 36 36 + } 37 37 + 38 38 + for _, pull := range pulls { 39 39 + items, err := rp.createPullItems(ctx, pull, f) 40 40 + if err != nil { 41 41 + return nil, err 42 42 + } 43 43 + feed.Items = append(feed.Items, items...) 44 44 + } 45 45 + 46 46 + for _, issue := range issues { 47 47 + item, err := rp.createIssueItem(ctx, issue, f) 48 48 + if err != nil { 49 49 + return nil, err 50 50 + } 51 51 + feed.Items = append(feed.Items, item) 52 52 + } 53 53 + 54 54 + slices.SortFunc(feed.Items, func(a, b *feeds.Item) int { 55 55 + if a.Created.After(b.Created) { 56 56 + return -1 57 57 + } 58 58 + return 1 59 59 + }) 60 60 + 61 61 + if len(feed.Items) > 0 { 62 62 + feed.Updated = feed.Items[0].Created 63 63 + } 64 64 + 65 65 + return feed, nil 66 66 + } 67 67 + 68 68 + func (rp *Repo) createPullItems(ctx context.Context, pull *db.Pull, f *reporesolver.ResolvedRepo) ([]*feeds.Item, error) { 69 69 + owner, err := rp.idResolver.ResolveIdent(ctx, pull.OwnerDid) 70 70 + if err != nil { 71 71 + return nil, err 72 72 + } 73 73 + 74 74 + var items []*feeds.Item 75 75 + 76 76 + state := rp.getPullState(pull) 77 77 + description := rp.buildPullDescription(owner.Handle, state, pull, f.OwnerSlashRepo()) 78 78 + 79 79 + mainItem := &feeds.Item{ 80 80 + Title: fmt.Sprintf("[PR #%d] %s", pull.PullId, pull.Title), 81 81 + Description: description, 82 82 + Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId)}, 83 83 + Created: pull.Created, 84 84 + Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)}, 85 85 + } 86 86 + items = append(items, mainItem) 87 87 + 88 88 + for _, round := range pull.Submissions { 89 89 + if round == nil || round.RoundNumber == 0 { 90 90 + continue 91 91 + } 92 92 + 93 93 + roundItem := &feeds.Item{ 94 94 + Title: fmt.Sprintf("[PR #%d] %s (round #%d)", pull.PullId, pull.Title, round.RoundNumber), 95 95 + Description: fmt.Sprintf("@%s submitted changes (at round #%d) on PR #%d in %s", owner.Handle, round.RoundNumber, pull.PullId, f.OwnerSlashRepo()), 96 96 + Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/pulls/%d/round/%d/", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), pull.PullId, round.RoundNumber)}, 97 97 + Created: round.Created, 98 98 + Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)}, 99 99 + } 100 100 + items = append(items, roundItem) 101 101 + } 102 102 + 103 103 + return items, nil 104 104 + } 105 105 + 106 106 + func (rp *Repo) createIssueItem(ctx context.Context, issue db.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) { 107 107 + owner, err := rp.idResolver.ResolveIdent(ctx, issue.OwnerDid) 108 108 + if err != nil { 109 109 + return nil, err 110 110 + } 111 111 + 112 112 + state := "closed" 113 113 + if issue.Open { 114 114 + state = "opened" 115 115 + } 116 116 + 117 117 + return &feeds.Item{ 118 118 + Title: fmt.Sprintf("[Issue #%d] %s", issue.IssueId, issue.Title), 119 119 + Description: fmt.Sprintf("@%s %s issue #%d in %s", owner.Handle, state, issue.IssueId, f.OwnerSlashRepo()), 120 120 + Link: &feeds.Link{Href: fmt.Sprintf("%s/%s/issues/%d", rp.config.Core.AppviewHost, f.OwnerSlashRepo(), issue.IssueId)}, 121 121 + Created: issue.Created, 122 122 + Author: &feeds.Author{Name: fmt.Sprintf("@%s", owner.Handle)}, 123 123 + }, nil 124 124 + } 125 125 + 126 126 + func (rp *Repo) getPullState(pull *db.Pull) string { 127 127 + if pull.State == db.PullOpen { 128 128 + return "opened" 129 129 + } 130 130 + return pull.State.String() 131 131 + } 132 132 + 133 133 + func (rp *Repo) buildPullDescription(handle syntax.Handle, state string, pull *db.Pull, repoName string) string { 134 134 + base := fmt.Sprintf("@%s %s pull request #%d", handle, state, pull.PullId) 135 135 + 136 136 + if pull.State == db.PullMerged { 137 137 + return fmt.Sprintf("%s (on round #%d) in %s", base, pull.LastRoundNumber(), repoName) 138 138 + } 139 139 + 140 140 + return fmt.Sprintf("%s in %s", base, repoName) 141 141 + } 142 142 + 143 143 + func (rp *Repo) RepoAtomFeed(w http.ResponseWriter, r *http.Request) { 144 144 + f, err := rp.repoResolver.Resolve(r) 145 145 + if err != nil { 146 146 + log.Println("failed to fully resolve repo:", err) 147 147 + return 148 148 + } 149 149 + 150 150 + feed, err := rp.getRepoFeed(r.Context(), f) 151 151 + if err != nil { 152 152 + log.Println("failed to get repo feed:", err) 153 153 + rp.pages.Error500(w) 154 154 + return 155 155 + } 156 156 + 157 157 + atom, err := feed.ToAtom() 158 158 + if err != nil { 159 159 + rp.pages.Error500(w) 160 160 + return 161 161 + } 162 162 + 163 163 + w.Header().Set("content-type", "application/atom+xml") 164 164 + w.Write([]byte(atom)) 165 165 + }

+12 -9

appview/repo/index.go

··· 24 24 25 25 func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) { 26 26 ref := chi.URLParam(r, "ref") 27 27 + 27 28 f, err := rp.repoResolver.Resolve(r) 28 29 if err != nil { 29 30 log.Println("failed to fully resolve repo", err) ··· 118 119 119 120 var forkInfo *types.ForkInfo 120 121 if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) { 121 121 - forkInfo, err = getForkInfo(repoInfo, rp, f, user, signedClient) 122 122 + forkInfo, err = getForkInfo(repoInfo, rp, f, result.Ref, user, signedClient) 122 123 if err != nil { 123 124 log.Printf("Failed to fetch fork information: %v", err) 124 125 return ··· 126 127 } 127 128 128 129 // TODO: a bit dirty 129 129 - languageInfo, err := rp.getLanguageInfo(f, signedClient, chi.URLParam(r, "ref") == "") 130 130 + languageInfo, err := rp.getLanguageInfo(f, signedClient, result.Ref, ref == "") 130 131 if err != nil { 131 132 log.Printf("failed to compute language percentages: %s", err) 132 133 // non-fatal ··· 161 162 func (rp *Repo) getLanguageInfo( 162 163 f *reporesolver.ResolvedRepo, 163 164 signedClient *knotclient.SignedClient, 165 165 + currentRef string, 164 166 isDefaultRef bool, 165 167 ) ([]types.RepoLanguageDetails, error) { 166 168 // first attempt to fetch from db 167 169 langs, err := db.GetRepoLanguages( 168 170 rp.db, 169 171 db.FilterEq("repo_at", f.RepoAt()), 170 170 - db.FilterEq("ref", f.Ref), 172 172 + db.FilterEq("ref", currentRef), 171 173 ) 172 174 173 175 if err != nil || langs == nil { 174 176 // non-fatal, fetch langs from ks 175 175 - ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref) 177 177 + ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, currentRef) 176 178 if err != nil { 177 179 return nil, err 178 180 } ··· 183 185 for l, s := range ls.Languages { 184 186 langs = append(langs, db.RepoLanguage{ 185 187 RepoAt: f.RepoAt(), 186 186 - Ref: f.Ref, 188 188 + Ref: currentRef, 187 189 IsDefaultRef: isDefaultRef, 188 190 Language: l, 189 191 Bytes: s, ··· 234 236 repoInfo repoinfo.RepoInfo, 235 237 rp *Repo, 236 238 f *reporesolver.ResolvedRepo, 239 239 + currentRef string, 237 240 user *oauth.User, 238 241 signedClient *knotclient.SignedClient, 239 242 ) (*types.ForkInfo, error) { ··· 264 267 } 265 268 266 269 if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool { 267 267 - return branch.Name == f.Ref 270 270 + return branch.Name == currentRef 268 271 }) { 269 272 forkInfo.Status = types.MissingBranch 270 273 return &forkInfo, nil 271 274 } 272 275 273 273 - newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, f.Ref, f.Ref) 276 276 + newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, currentRef, currentRef) 274 277 if err != nil || newHiddenRefResp.StatusCode != http.StatusNoContent { 275 278 log.Printf("failed to update tracking branch: %s", err) 276 279 return nil, err 277 280 } 278 281 279 279 - hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref) 282 282 + hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef) 280 283 281 284 var status types.AncestorCheckResponse 282 282 - forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef) 285 285 + forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef) 283 286 if err != nil { 284 287 log.Printf("failed to check if fork is ahead/behind: %s", err) 285 288 return nil, err

+25 -3

appview/repo/repo.go

··· 612 612 if !rp.config.Core.Dev { 613 613 protocol = "https" 614 614 } 615 615 + 615 616 blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath) 616 616 - resp, err := http.Get(blobURL) 617 617 + 618 618 + req, err := http.NewRequest("GET", blobURL, nil) 617 619 if err != nil { 618 618 - log.Println("failed to reach knotserver:", err) 620 620 + log.Println("failed to create request", err) 621 621 + return 622 622 + } 623 623 + 624 624 + // forward the If-None-Match header 625 625 + if clientETag := r.Header.Get("If-None-Match"); clientETag != "" { 626 626 + req.Header.Set("If-None-Match", clientETag) 627 627 + } 628 628 + 629 629 + client := &http.Client{} 630 630 + resp, err := client.Do(req) 631 631 + if err != nil { 632 632 + log.Println("failed to reach knotserver", err) 619 633 rp.pages.Error503(w) 620 634 return 621 635 } 622 636 defer resp.Body.Close() 637 637 + 638 638 + // forward 304 not modified 639 639 + if resp.StatusCode == http.StatusNotModified { 640 640 + w.WriteHeader(http.StatusNotModified) 641 641 + return 642 642 + } 623 643 624 644 if resp.StatusCode != http.StatusOK { 625 645 log.Printf("knotserver returned non-OK status for raw blob %s: %d", blobURL, resp.StatusCode) ··· 1315 1335 } 1316 1336 1317 1337 func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) { 1338 1338 + ref := chi.URLParam(r, "ref") 1339 1339 + 1318 1340 user := rp.oauth.GetUser(r) 1319 1341 f, err := rp.repoResolver.Resolve(r) 1320 1342 if err != nil { ··· 1345 1367 forkName := fmt.Sprintf("%s", f.Name) 1346 1368 forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name) 1347 1369 1348 1348 - _, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref) 1370 1370 + _, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, ref) 1349 1371 if err != nil { 1350 1372 rp.pages.Notice(w, "repo", "Failed to sync repository fork.") 1351 1373 return

+1

appview/repo/router.go

··· 10 10 func (rp *Repo) Router(mw *middleware.Middleware) http.Handler { 11 11 r := chi.NewRouter() 12 12 r.Get("/", rp.RepoIndex) 13 13 + r.Get("/feed.atom", rp.RepoAtomFeed) 13 14 r.Get("/commits/{ref}", rp.RepoLog) 14 15 r.Route("/tree/{ref}", func(r chi.Router) { 15 16 r.Get("/", rp.RepoIndex)

+17 -51

appview/reporesolver/resolver.go

··· 7 7 "fmt" 8 8 "log" 9 9 "net/http" 10 10 - "net/url" 11 10 "path" 11 11 + "regexp" 12 12 "strings" 13 13 14 14 "github.com/bluesky-social/indigo/atproto/identity" ··· 20 20 "tangled.sh/tangled.sh/core/appview/pages" 21 21 "tangled.sh/tangled.sh/core/appview/pages/repoinfo" 22 22 "tangled.sh/tangled.sh/core/idresolver" 23 23 - "tangled.sh/tangled.sh/core/knotclient" 24 23 "tangled.sh/tangled.sh/core/rbac" 25 24 ) 26 25 27 26 type ResolvedRepo struct { 28 27 db.Repo 29 29 - OwnerId identity.Identity 30 30 - Ref string 31 31 - CurrentDir string 28 28 + OwnerId identity.Identity 29 29 + CurrentDir string 30 30 + Ref string 32 31 33 32 rr *RepoResolver 34 33 } ··· 56 55 return nil, fmt.Errorf("malformed middleware") 57 56 } 58 57 58 58 + currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath())) 59 59 ref := chi.URLParam(r, "ref") 60 60 61 61 - if ref == "" { 62 62 - us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev) 63 63 - if err != nil { 64 64 - return nil, err 65 65 - } 66 66 - 67 67 - defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name) 68 68 - if err != nil { 69 69 - return nil, err 70 70 - } 71 71 - 72 72 - ref = defaultBranch.Branch 73 73 - } 74 74 - 75 75 - currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref)) 76 76 - 77 61 return &ResolvedRepo{ 78 62 Repo: *repo, 79 63 OwnerId: id, 80 80 - Ref: ref, 81 64 CurrentDir: currentDir, 65 65 + Ref: ref, 82 66 83 67 rr: rr, 84 68 }, nil ··· 195 179 } 196 180 197 181 knot := f.Knot 198 198 - var disableFork bool 199 199 - us, err := knotclient.NewUnsignedClient(knot, f.rr.config.Core.Dev) 200 200 - if err != nil { 201 201 - log.Printf("failed to create unsigned client for %s: %v", knot, err) 202 202 - } else { 203 203 - result, err := us.Branches(f.OwnerDid(), f.Name) 204 204 - if err != nil { 205 205 - log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err) 206 206 - } 207 207 - 208 208 - if len(result.Branches) == 0 { 209 209 - disableFork = true 210 210 - } 211 211 - } 212 182 213 183 repoInfo := repoinfo.RepoInfo{ 214 184 OwnerDid: f.OwnerDid(), ··· 216 186 Name: f.Name, 217 187 RepoAt: repoAt, 218 188 Description: f.Description, 219 219 - Ref: f.Ref, 220 189 IsStarred: isStarred, 221 190 Knot: knot, 222 191 Spindle: f.Spindle, ··· 226 195 IssueCount: issueCount, 227 196 PullCount: pullCount, 228 197 }, 229 229 - DisableFork: disableFork, 230 230 - CurrentDir: f.CurrentDir, 198 198 + CurrentDir: f.CurrentDir, 199 199 + Ref: f.Ref, 231 200 } 232 201 233 202 if sourceRepo != nil { ··· 251 220 // after the ref. for example: 252 221 // 253 222 // /@icyphox.sh/foorepo/blob/main/abc/xyz/ => abc/xyz/ 254 254 - func extractPathAfterRef(fullPath, ref string) string { 223 223 + func extractPathAfterRef(fullPath string) string { 255 224 fullPath = strings.TrimPrefix(fullPath, "/") 256 225 257 257 - ref = url.PathEscape(ref) 226 226 + // match blob/, tree/, or raw/ followed by any ref and then a slash 227 227 + // 228 228 + // captures everything after the final slash 229 229 + pattern := `(?:blob|tree|raw)/[^/]+/(.*)$` 258 230 259 259 - prefixes := []string{ 260 260 - fmt.Sprintf("blob/%s/", ref), 261 261 - fmt.Sprintf("tree/%s/", ref), 262 262 - fmt.Sprintf("raw/%s/", ref), 263 263 - } 231 231 + re := regexp.MustCompile(pattern) 232 232 + matches := re.FindStringSubmatch(fullPath) 264 233 265 265 - for _, prefix := range prefixes { 266 266 - idx := strings.Index(fullPath, prefix) 267 267 - if idx != -1 { 268 268 - return fullPath[idx+len(prefix):] 269 269 - } 234 234 + if len(matches) > 1 { 235 235 + return matches[1] 270 236 } 271 237 272 238 return ""

+9 -12

appview/state/git_http.go

··· 3 3 import ( 4 4 "fmt" 5 5 "io" 6 6 + "maps" 6 7 "net/http" 7 8 8 9 "github.com/bluesky-social/indigo/atproto/identity" 9 10 "github.com/go-chi/chi/v5" 11 11 + "tangled.sh/tangled.sh/core/appview/db" 10 12 ) 11 13 12 14 func (s *State) InfoRefs(w http.ResponseWriter, r *http.Request) { 13 15 user := r.Context().Value("resolvedId").(identity.Identity) 14 14 - knot := r.Context().Value("knot").(string) 15 15 - repo := chi.URLParam(r, "repo") 16 16 + repo := r.Context().Value("repo").(*db.Repo) 16 17 17 18 scheme := "https" 18 19 if s.config.Core.Dev { 19 20 scheme = "http" 20 21 } 21 22 22 22 - targetURL := fmt.Sprintf("%s://%s/%s/%s/info/refs?%s", scheme, knot, user.DID, repo, r.URL.RawQuery) 23 23 + targetURL := fmt.Sprintf("%s://%s/%s/%s/info/refs?%s", scheme, repo.Knot, user.DID, repo.Name, r.URL.RawQuery) 23 24 s.proxyRequest(w, r, targetURL) 24 25 25 26 } ··· 30 31 http.Error(w, "failed to resolve user", http.StatusInternalServerError) 31 32 return 32 33 } 33 33 - knot := r.Context().Value("knot").(string) 34 34 - repo := chi.URLParam(r, "repo") 34 34 + repo := r.Context().Value("repo").(*db.Repo) 35 35 36 36 scheme := "https" 37 37 if s.config.Core.Dev { 38 38 scheme = "http" 39 39 } 40 40 41 41 - targetURL := fmt.Sprintf("%s://%s/%s/%s/git-upload-pack?%s", scheme, knot, user.DID, repo, r.URL.RawQuery) 41 41 + targetURL := fmt.Sprintf("%s://%s/%s/%s/git-upload-pack?%s", scheme, repo.Knot, user.DID, repo.Name, r.URL.RawQuery) 42 42 s.proxyRequest(w, r, targetURL) 43 43 } 44 44 ··· 48 48 http.Error(w, "failed to resolve user", http.StatusInternalServerError) 49 49 return 50 50 } 51 51 - knot := r.Context().Value("knot").(string) 52 52 - repo := chi.URLParam(r, "repo") 51 51 + repo := r.Context().Value("repo").(*db.Repo) 53 52 54 53 scheme := "https" 55 54 if s.config.Core.Dev { 56 55 scheme = "http" 57 56 } 58 57 59 59 - targetURL := fmt.Sprintf("%s://%s/%s/%s/git-receive-pack?%s", scheme, knot, user.DID, repo, r.URL.RawQuery) 58 58 + targetURL := fmt.Sprintf("%s://%s/%s/%s/git-receive-pack?%s", scheme, repo.Knot, user.DID, repo.Name, r.URL.RawQuery) 60 59 s.proxyRequest(w, r, targetURL) 61 60 } 62 61 ··· 85 84 defer resp.Body.Close() 86 85 87 86 // Copy response headers 88 88 - for k, v := range resp.Header { 89 89 - w.Header()[k] = v 90 90 - } 87 87 + maps.Copy(w.Header(), resp.Header) 91 88 92 89 // Set response status code 93 90 w.WriteHeader(resp.StatusCode)

+95 -82

appview/state/profile.go

··· 89 89 log.Printf("failed to create profile timeline for %s: %s", ident.DID.String(), err) 90 90 } 91 91 92 92 - var didsToResolve []string 93 93 - for _, r := range collaboratingRepos { 94 94 - didsToResolve = append(didsToResolve, r.Did) 95 95 - } 96 96 - for _, byMonth := range timeline.ByMonth { 97 97 - for _, pe := range byMonth.PullEvents.Items { 98 98 - didsToResolve = append(didsToResolve, pe.Repo.Did) 99 99 - } 100 100 - for _, ie := range byMonth.IssueEvents.Items { 101 101 - didsToResolve = append(didsToResolve, ie.Metadata.Repo.Did) 102 102 - } 103 103 - for _, re := range byMonth.RepoEvents { 104 104 - didsToResolve = append(didsToResolve, re.Repo.Did) 105 105 - if re.Source != nil { 106 106 - didsToResolve = append(didsToResolve, re.Source.Did) 107 107 - } 108 108 - } 109 109 - } 110 110 - 111 92 followers, following, err := db.GetFollowerFollowingCount(s.db, ident.DID.String()) 112 93 if err != nil { 113 94 log.Printf("getting follow stats repos for %s: %s", ident.DID.String(), err) ··· 194 175 }) 195 176 } 196 177 197 197 - func (s *State) feedFromRequest(w http.ResponseWriter, r *http.Request) *feeds.Feed { 178 178 + func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { 198 179 ident, ok := r.Context().Value("resolvedId").(identity.Identity) 199 180 if !ok { 200 181 s.pages.Error404(w) 201 201 - return nil 182 182 + return 202 183 } 203 184 204 204 - feed, err := s.GetProfileFeed(r.Context(), ident.Handle.String(), ident.DID.String()) 185 185 + feed, err := s.getProfileFeed(r.Context(), &ident) 205 186 if err != nil { 206 187 s.pages.Error500(w) 207 207 - return nil 188 188 + return 208 189 } 209 190 210 210 - return feed 211 211 - } 212 212 - 213 213 - func (s *State) AtomFeedPage(w http.ResponseWriter, r *http.Request) { 214 214 - feed := s.feedFromRequest(w, r) 215 191 if feed == nil { 216 192 return 217 193 } ··· 226 202 w.Write([]byte(atom)) 227 203 } 228 204 229 229 - func (s *State) GetProfileFeed(ctx context.Context, handle string, did string) (*feeds.Feed, error) { 230 230 - timeline, err := db.MakeProfileTimeline(s.db, did) 205 205 + func (s *State) getProfileFeed(ctx context.Context, id *identity.Identity) (*feeds.Feed, error) { 206 206 + timeline, err := db.MakeProfileTimeline(s.db, id.DID.String()) 231 207 if err != nil { 232 208 return nil, err 233 209 } 234 210 235 211 author := &feeds.Author{ 236 236 - Name: fmt.Sprintf("@%s", handle), 212 212 + Name: fmt.Sprintf("@%s", id.Handle), 237 213 } 238 238 - feed := &feeds.Feed{ 239 239 - Title: fmt.Sprintf("timeline feed for %s", author.Name), 240 240 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.AppviewHost, handle), Type: "text/html", Rel: "alternate"}, 214 214 + 215 215 + feed := feeds.Feed{ 216 216 + Title: fmt.Sprintf("%s's timeline", author.Name), 217 217 + Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s", s.config.Core.AppviewHost, id.Handle), Type: "text/html", Rel: "alternate"}, 241 218 Items: make([]*feeds.Item, 0), 242 219 Updated: time.UnixMilli(0), 243 220 Author: author, 244 221 } 222 222 + 245 223 for _, byMonth := range timeline.ByMonth { 246 246 - for _, pull := range byMonth.PullEvents.Items { 247 247 - owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did) 248 248 - if err != nil { 249 249 - return nil, err 250 250 - } 251 251 - feed.Items = append(feed.Items, &feeds.Item{ 252 252 - Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name), 253 253 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"}, 254 254 - Created: pull.Created, 255 255 - Author: author, 256 256 - }) 257 257 - for _, submission := range pull.Submissions { 258 258 - feed.Items = append(feed.Items, &feeds.Item{ 259 259 - Title: fmt.Sprintf("%s submitted pull request '%s' (round #%d) in @%s/%s", author.Name, pull.Title, submission.RoundNumber, owner.Handle, pull.Repo.Name), 260 260 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"}, 261 261 - Created: submission.Created, 262 262 - Author: author, 263 263 - }) 264 264 - } 224 224 + if err := s.addPullRequestItems(ctx, &feed, byMonth.PullEvents.Items, author); err != nil { 225 225 + return nil, err 265 226 } 266 266 - for _, issue := range byMonth.IssueEvents.Items { 267 267 - owner, err := s.idResolver.ResolveIdent(ctx, issue.Metadata.Repo.Did) 268 268 - if err != nil { 269 269 - return nil, err 270 270 - } 271 271 - feed.Items = append(feed.Items, &feeds.Item{ 272 272 - Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Metadata.Repo.Name), 273 273 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Metadata.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"}, 274 274 - Created: issue.Created, 275 275 - Author: author, 276 276 - }) 227 227 + if err := s.addIssueItems(ctx, &feed, byMonth.IssueEvents.Items, author); err != nil { 228 228 + return nil, err 277 229 } 278 278 - for _, repo := range byMonth.RepoEvents { 279 279 - var title string 280 280 - if repo.Source != nil { 281 281 - id, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did) 282 282 - if err != nil { 283 283 - return nil, err 284 284 - } 285 285 - title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, id.Handle, repo.Source.Name, repo.Repo.Name) 286 286 - } else { 287 287 - title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name) 288 288 - } 289 289 - feed.Items = append(feed.Items, &feeds.Item{ 290 290 - Title: title, 291 291 - Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.AppviewHost, handle, repo.Repo.Name), Type: "text/html", Rel: "alternate"}, 292 292 - Created: repo.Repo.Created, 293 293 - Author: author, 294 294 - }) 230 230 + if err := s.addRepoItems(ctx, &feed, byMonth.RepoEvents, author); err != nil { 231 231 + return nil, err 295 232 } 296 233 } 234 234 + 297 235 slices.SortFunc(feed.Items, func(a *feeds.Item, b *feeds.Item) int { 298 236 return int(b.Created.UnixMilli()) - int(a.Created.UnixMilli()) 299 237 }) 238 238 + 300 239 if len(feed.Items) > 0 { 301 240 feed.Updated = feed.Items[0].Created 302 241 } 303 242 304 304 - return feed, nil 243 243 + return &feed, nil 244 244 + } 245 245 + 246 246 + func (s *State) addPullRequestItems(ctx context.Context, feed *feeds.Feed, pulls []*db.Pull, author *feeds.Author) error { 247 247 + for _, pull := range pulls { 248 248 + owner, err := s.idResolver.ResolveIdent(ctx, pull.Repo.Did) 249 249 + if err != nil { 250 250 + return err 251 251 + } 252 252 + 253 253 + // Add pull request creation item 254 254 + feed.Items = append(feed.Items, s.createPullRequestItem(pull, owner, author)) 255 255 + } 256 256 + return nil 257 257 + } 258 258 + 259 259 + func (s *State) addIssueItems(ctx context.Context, feed *feeds.Feed, issues []*db.Issue, author *feeds.Author) error { 260 260 + for _, issue := range issues { 261 261 + owner, err := s.idResolver.ResolveIdent(ctx, issue.Metadata.Repo.Did) 262 262 + if err != nil { 263 263 + return err 264 264 + } 265 265 + 266 266 + feed.Items = append(feed.Items, s.createIssueItem(issue, owner, author)) 267 267 + } 268 268 + return nil 269 269 + } 270 270 + 271 271 + func (s *State) addRepoItems(ctx context.Context, feed *feeds.Feed, repos []db.RepoEvent, author *feeds.Author) error { 272 272 + for _, repo := range repos { 273 273 + item, err := s.createRepoItem(ctx, repo, author) 274 274 + if err != nil { 275 275 + return err 276 276 + } 277 277 + feed.Items = append(feed.Items, item) 278 278 + } 279 279 + return nil 280 280 + } 281 281 + 282 282 + func (s *State) createPullRequestItem(pull *db.Pull, owner *identity.Identity, author *feeds.Author) *feeds.Item { 283 283 + return &feeds.Item{ 284 284 + Title: fmt.Sprintf("%s created pull request '%s' in @%s/%s", author.Name, pull.Title, owner.Handle, pull.Repo.Name), 285 285 + Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/pulls/%d", s.config.Core.AppviewHost, owner.Handle, pull.Repo.Name, pull.PullId), Type: "text/html", Rel: "alternate"}, 286 286 + Created: pull.Created, 287 287 + Author: author, 288 288 + } 289 289 + } 290 290 + 291 291 + func (s *State) createIssueItem(issue *db.Issue, owner *identity.Identity, author *feeds.Author) *feeds.Item { 292 292 + return &feeds.Item{ 293 293 + Title: fmt.Sprintf("%s created issue '%s' in @%s/%s", author.Name, issue.Title, owner.Handle, issue.Metadata.Repo.Name), 294 294 + Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s/issues/%d", s.config.Core.AppviewHost, owner.Handle, issue.Metadata.Repo.Name, issue.IssueId), Type: "text/html", Rel: "alternate"}, 295 295 + Created: issue.Created, 296 296 + Author: author, 297 297 + } 298 298 + } 299 299 + 300 300 + func (s *State) createRepoItem(ctx context.Context, repo db.RepoEvent, author *feeds.Author) (*feeds.Item, error) { 301 301 + var title string 302 302 + if repo.Source != nil { 303 303 + sourceOwner, err := s.idResolver.ResolveIdent(ctx, repo.Source.Did) 304 304 + if err != nil { 305 305 + return nil, err 306 306 + } 307 307 + title = fmt.Sprintf("%s forked repository @%s/%s to '%s'", author.Name, sourceOwner.Handle, repo.Source.Name, repo.Repo.Name) 308 308 + } else { 309 309 + title = fmt.Sprintf("%s created repository '%s'", author.Name, repo.Repo.Name) 310 310 + } 311 311 + 312 312 + return &feeds.Item{ 313 313 + Title: title, 314 314 + Link: &feeds.Link{Href: fmt.Sprintf("%s/@%s/%s", s.config.Core.AppviewHost, author.Name[1:], repo.Repo.Name), Type: "text/html", Rel: "alternate"}, // Remove @ prefix 315 315 + Created: repo.Repo.Created, 316 316 + Author: author, 317 317 + }, nil 305 318 } 306 319 307 320 func (s *State) UpdateProfileBio(w http.ResponseWriter, r *http.Request) {

+5 -2

appview/state/router.go

··· 35 35 router.Get("/favicon.svg", s.Favicon) 36 36 router.Get("/favicon.ico", s.Favicon) 37 37 38 38 + userRouter := s.UserRouter(&middleware) 39 39 + standardRouter := s.StandardRouter(&middleware) 40 40 + 38 41 router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) { 39 42 pat := chi.URLParam(r, "*") 40 43 if strings.HasPrefix(pat, "did:") || strings.HasPrefix(pat, "@") { 41 41 - s.UserRouter(&middleware).ServeHTTP(w, r) 44 44 + userRouter.ServeHTTP(w, r) 42 45 } else { 43 46 // Check if the first path element is a valid handle without '@' or a flattened DID 44 47 pathParts := strings.SplitN(pat, "/", 2) ··· 61 64 return 62 65 } 63 66 } 64 64 - s.StandardRouter(&middleware).ServeHTTP(w, r) 67 67 + standardRouter.ServeHTTP(w, r) 65 68 } 66 69 }) 67 70

+10

appview/state/state.go

··· 94 94 tangled.SpindleMemberNSID, 95 95 tangled.SpindleNSID, 96 96 tangled.StringNSID, 97 97 + tangled.RepoIssueNSID, 98 98 + tangled.RepoIssueCommentNSID, 97 99 }, 98 100 nil, 99 101 slog.Default(), ··· 193 195 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.") 194 196 } 195 197 198 198 + repos, err := db.GetTopStarredReposLastWeek(s.db) 199 199 + if err != nil { 200 200 + log.Println(err) 201 201 + s.pages.Notice(w, "topstarredrepos", "Unable to load.") 202 202 + return 203 203 + } 204 204 + 196 205 s.pages.Timeline(w, pages.TimelineParams{ 197 206 LoggedInUser: user, 198 207 Timeline: timeline, 208 208 + Repos: repos, 199 209 }) 200 210 } 201 211

+23 -12

appview/strings/strings.go

··· 7 7 "path" 8 8 "slices" 9 9 "strconv" 10 10 - "strings" 11 10 "time" 12 11 13 12 "tangled.sh/tangled.sh/core/api/tangled" ··· 44 43 r := chi.NewRouter() 45 44 46 45 r. 46 46 + Get("/", s.timeline) 47 47 + 48 48 + r. 47 49 With(mw.ResolveIdent()). 48 50 Route("/{user}", func(r chi.Router) { 49 51 r.Get("/", s.dashboard) ··· 70 72 return r 71 73 } 72 74 75 75 + func (s *Strings) timeline(w http.ResponseWriter, r *http.Request) { 76 76 + l := s.Logger.With("handler", "timeline") 77 77 + 78 78 + strings, err := db.GetStrings(s.Db, 50) 79 79 + if err != nil { 80 80 + l.Error("failed to fetch string", "err", err) 81 81 + w.WriteHeader(http.StatusInternalServerError) 82 82 + return 83 83 + } 84 84 + 85 85 + s.Pages.StringsTimeline(w, pages.StringTimelineParams{ 86 86 + LoggedInUser: s.OAuth.GetUser(r), 87 87 + Strings: strings, 88 88 + }) 89 89 + } 90 90 + 73 91 func (s *Strings) contents(w http.ResponseWriter, r *http.Request) { 74 92 l := s.Logger.With("handler", "contents") 75 93 ··· 91 109 92 110 strings, err := db.GetStrings( 93 111 s.Db, 112 112 + 0, 94 113 db.FilterEq("did", id.DID), 95 114 db.FilterEq("rkey", rkey), 96 115 ) ··· 154 173 155 174 all, err := db.GetStrings( 156 175 s.Db, 176 176 + 0, 157 177 db.FilterEq("did", id.DID), 158 178 ) 159 179 if err != nil { ··· 225 245 // get the string currently being edited 226 246 all, err := db.GetStrings( 227 247 s.Db, 248 248 + 0, 228 249 db.FilterEq("did", id.DID), 229 250 db.FilterEq("rkey", rkey), 230 251 ) ··· 266 287 fail("Empty filename.", nil) 267 288 return 268 289 } 269 269 - if !strings.Contains(filename, ".") { 270 270 - // TODO: make this a htmx form validation 271 271 - fail("No extension provided for filename.", nil) 272 272 - return 273 273 - } 274 290 275 291 content := r.FormValue("content") 276 292 if content == "" { ··· 353 369 fail("Empty filename.", nil) 354 370 return 355 371 } 356 356 - if !strings.Contains(filename, ".") { 357 357 - // TODO: make this a htmx form validation 358 358 - fail("No extension provided for filename.", nil) 359 359 - return 360 360 - } 361 372 362 373 content := r.FormValue("content") 363 374 if content == "" { ··· 434 445 } 435 446 436 447 if user.Did != id.DID.String() { 437 437 - fail("You cannot delete this gist", fmt.Errorf("unauthorized deletion, %s != %s", user.Did, id.DID.String())) 448 448 + fail("You cannot delete this string", fmt.Errorf("unauthorized deletion, %s != %s", user.Did, id.DID.String())) 438 449 return 439 450 } 440 451

+1 -1

input.css

··· 103 103 } 104 104 105 105 code { 106 106 - @apply font-mono rounded bg-gray-100 dark:bg-gray-700; 106 106 + @apply font-mono rounded bg-gray-100 dark:bg-gray-700 text-black dark:text-white; 107 107 } 108 108 } 109 109

+8 -10

knotserver/git/fork.go

··· 10 10 ) 11 11 12 12 func Fork(repoPath, source string) error { 13 13 - _, err := git.PlainClone(repoPath, true, &git.CloneOptions{ 14 14 - URL: source, 15 15 - SingleBranch: false, 16 16 - }) 17 17 - 18 18 - if err != nil { 13 13 + cloneCmd := exec.Command("git", "clone", "--bare", source, repoPath) 14 14 + if err := cloneCmd.Run(); err != nil { 19 15 return fmt.Errorf("failed to bare clone repository: %w", err) 20 16 } 21 17 22 22 - err = exec.Command("git", "-C", repoPath, "config", "receive.hideRefs", "refs/hidden").Run() 23 23 - if err != nil { 18 18 + configureCmd := exec.Command("git", "-C", repoPath, "config", "receive.hideRefs", "refs/hidden") 19 19 + if err := configureCmd.Run(); err != nil { 24 20 return fmt.Errorf("failed to configure hidden refs: %w", err) 25 21 } 26 22 27 23 return nil 28 24 } 29 25 30 30 - func (g *GitRepo) Sync(branch string) error { 26 26 + func (g *GitRepo) Sync() error { 27 27 + branch := g.h.String() 28 28 + 31 29 fetchOpts := &git.FetchOptions{ 32 30 RefSpecs: []config.RefSpec{ 33 33 - config.RefSpec(fmt.Sprintf("+refs/heads/%s:refs/heads/%s", branch, branch)), 31 31 + config.RefSpec("+" + branch + ":" + branch), // +refs/heads/master:refs/heads/master 34 32 }, 35 33 } 36 34

+1

knotserver/git.go

··· 129 129 // If the appview gave us the repository owner's handle we can attempt to 130 130 // construct the correct ssh url. 131 131 ownerHandle := r.Header.Get("x-tangled-repo-owner-handle") 132 132 + ownerHandle = strings.TrimPrefix(ownerHandle, "@") 132 133 if ownerHandle != "" && !strings.ContainsAny(ownerHandle, ":") { 133 134 hostname := d.c.Server.Hostname 134 135 if strings.Contains(hostname, ":") {

+2 -2

knotserver/handler.go

··· 142 142 r.Delete("/", h.RemoveRepo) 143 143 r.Route("/fork", func(r chi.Router) { 144 144 r.Post("/", h.RepoFork) 145 145 - r.Post("/sync/{branch}", h.RepoForkSync) 146 146 - r.Get("/sync/{branch}", h.RepoForkAheadBehind) 145 145 + r.Post("/sync/*", h.RepoForkSync) 146 146 + r.Get("/sync/*", h.RepoForkAheadBehind) 147 147 }) 148 148 }) 149 149

+16 -11

knotserver/routes.go

··· 286 286 mimeType = "image/svg+xml" 287 287 } 288 288 289 289 + contentHash := sha256.Sum256(contents) 290 290 + eTag := fmt.Sprintf("\"%x\"", contentHash) 291 291 + 289 292 // allow image, video, and text/plain files to be served directly 290 293 switch { 291 291 - case strings.HasPrefix(mimeType, "image/"): 292 292 - // allowed 293 293 - case strings.HasPrefix(mimeType, "video/"): 294 294 - // allowed 294 294 + case strings.HasPrefix(mimeType, "image/"), strings.HasPrefix(mimeType, "video/"): 295 295 + if clientETag := r.Header.Get("If-None-Match"); clientETag == eTag { 296 296 + w.WriteHeader(http.StatusNotModified) 297 297 + return 298 298 + } 299 299 + w.Header().Set("ETag", eTag) 300 300 + 295 301 case strings.HasPrefix(mimeType, "text/plain"): 296 296 - // allowed 302 302 + w.Header().Set("Cache-Control", "public, no-cache") 303 303 + 297 304 default: 298 305 l.Error("attempted to serve disallowed file type", "mimetype", mimeType) 299 306 writeError(w, "only image, video, and text files can be accessed directly", http.StatusForbidden) 300 307 return 301 308 } 302 309 303 303 - w.Header().Set("Cache-Control", "public, max-age=86400") // cache for 24 hours 304 304 - w.Header().Set("ETag", fmt.Sprintf("%x", sha256.Sum256(contents))) 305 310 w.Header().Set("Content-Type", mimeType) 306 311 w.Write(contents) 307 312 } ··· 710 715 } 711 716 712 717 func (h *Handle) RepoForkAheadBehind(w http.ResponseWriter, r *http.Request) { 713 713 - l := h.l.With("handler", "RepoForkSync") 718 718 + l := h.l.With("handler", "RepoForkAheadBehind") 714 719 715 720 data := struct { 716 721 Did string `json:"did"` ··· 845 850 name = filepath.Base(source) 846 851 } 847 852 848 848 - branch := chi.URLParam(r, "branch") 853 853 + branch := chi.URLParam(r, "*") 849 854 branch, _ = url.PathUnescape(branch) 850 855 851 856 relativeRepoPath := filepath.Join(did, name) 852 857 repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath) 853 858 854 854 - gr, err := git.PlainOpen(repoPath) 859 859 + gr, err := git.Open(repoPath, branch) 855 860 if err != nil { 856 861 log.Println(err) 857 862 notFound(w) 858 863 return 859 864 } 860 865 861 861 - err = gr.Sync(branch) 866 866 + err = gr.Sync() 862 867 if err != nil { 863 868 l.Error("error syncing repo fork", "error", err.Error()) 864 869 writeError(w, err.Error(), http.StatusInternalServerError)

+1 -8

lexicons/issue/comment.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "issue", 14 14 - "body", 15 15 - "createdAt" 16 16 - ], 12 12 + "required": ["issue", "body", "createdAt"], 17 13 "properties": { 18 14 "issue": { 19 15 "type": "string", ··· 22 18 "repo": { 23 19 "type": "string", 24 20 "format": "at-uri" 25 25 - }, 26 26 - "commentId": { 27 27 - "type": "integer" 28 21 }, 29 22 "owner": { 30 23 "type": "string",

+1 -10

lexicons/issue/issue.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": [ 13 13 - "repo", 14 14 - "issueId", 15 15 - "owner", 16 16 - "title", 17 17 - "createdAt" 18 18 - ], 12 12 + "required": ["repo", "owner", "title", "createdAt"], 19 13 "properties": { 20 14 "repo": { 21 15 "type": "string", 22 16 "format": "at-uri" 23 23 - }, 24 24 - "issueId": { 25 25 - "type": "integer" 26 17 }, 27 18 "owner": { 28 19 "type": "string",

+7 -6

spindle/engines/nixery/engine.go

··· 195 195 io.Copy(os.Stdout, reader) 196 196 197 197 resp, err := e.docker.ContainerCreate(ctx, &container.Config{ 198 198 - Image: addl.image, 199 199 - Cmd: []string{"cat"}, 200 200 - OpenStdin: true, // so cat stays alive :3 201 201 - Tty: false, 202 202 - Hostname: "spindle", 198 198 + Image: addl.image, 199 199 + Cmd: []string{"cat"}, 200 200 + OpenStdin: true, // so cat stays alive :3 201 201 + Tty: false, 202 202 + Hostname: "spindle", 203 203 + WorkingDir: workspaceDir, 203 204 // TODO(winter): investigate whether environment variables passed here 204 205 // get propagated to ContainerExec processes 205 206 }, &container.HostConfig{ ··· 304 305 envs.AddEnv(k, v) 305 306 } 306 307 envs.AddEnv("HOME", homeDir) 307 307 - e.l.Debug("envs for step", "step", step.Name, "envs", envs.Slice()) 308 308 309 309 mkExecResp, err := e.docker.ContainerExecCreate(ctx, addl.container, container.ExecOptions{ 310 310 Cmd: []string{"bash", "-c", step.command}, 311 311 AttachStdout: true, 312 312 AttachStderr: true, 313 313 + Env: envs, 313 314 }) 314 315 if err != nil { 315 316 return fmt.Errorf("creating exec: %w", err)