commit 1dcc4fac2ea332180014cbc87e4c22821699e66d · kot.pink/core

+27 -1

appview/repo/repo.go

···

       685
       685
        
       		return

     

       686
       686
        
       	}

     

       687
       687
        
       

     

       688
       688
       -
       	if strings.Contains(contentType, "text/plain") {

     

       688
       688
       +
       	// Safely serve content based on type

     

       689
       689
       +
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       690
       690
       +
       		// Serve all textual content as text/plain for security

     

       689
       691
        
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       690
       692
        
       		w.Write(body)

     

       691
       693
        
       	} else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {

     

       694
       694
       +
       		// Serve images and videos with their original content type

     

       692
       695
        
       		w.Header().Set("Content-Type", contentType)

     

       693
       696
        
       		w.Write(body)

     

       694
       697
        
       	} else {

     

       698
       698
       +
       		// Block potentially dangerous content types

     

       695
       699
        
       		w.WriteHeader(http.StatusUnsupportedMediaType)

     

       696
       700
        
       		w.Write([]byte("unsupported content type"))

     

       697
       701
        
       		return

     

       698
       702
        
       	}

     

       703
       703
       +
       }

     

       704
       704
       +
       

     

       705
       705
       +
       // isTextualMimeType returns true if the MIME type represents textual content

     

       706
       706
       +
       // that should be served as text/plain

     

       707
       707
       +
       func isTextualMimeType(mimeType string) bool {

     

       708
       708
       +
       	textualTypes := []string{

     

       709
       709
       +
       		"application/json",

     

       710
       710
       +
       		"application/xml",

     

       711
       711
       +
       		"application/yaml",

     

       712
       712
       +
       		"application/x-yaml",

     

       713
       713
       +
       		"application/toml",

     

       714
       714
       +
       		"application/javascript",

     

       715
       715
       +
       		"application/ecmascript",

     

       716
       716
       +
       		"message/",

     

       717
       717
       +
       	}

     

       718
       718
       +
       

     

       719
       719
       +
       	for _, t := range textualTypes {

     

       720
       720
       +
       		if mimeType == t {

     

       721
       721
       +
       			return true

     

       722
       722
       +
       		}

     

       723
       723
       +
       	}

     

       724
       724
       +
       	return false

     

       699
       725
        
       }

     

       700
       726
        
       

     

       701
       727
        
       // modify the spindle configured for this repo

+40

knotserver/db/pubkeys.go

···

       1
       1
        
       package db

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"strconv"

     

       4
       5
        
       	"time"

     

       5
       6
        
       

     

       6
       7
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     
···

       99
       100
        
       

     

       100
       101
        
       	return keys, nil

     

       101
       102
        
       }

     

       103
       103
       +
       

     

       104
       104
       +
       func (d *DB) GetPublicKeysPaginated(limit int, cursor string) ([]PublicKey, string, error) {

     

       105
       105
       +
       	var keys []PublicKey

     

       106
       106
       +
       

     

       107
       107
       +
       	offset := 0

     

       108
       108
       +
       	if cursor != "" {

     

       109
       109
       +
       		if o, err := strconv.Atoi(cursor); err == nil && o >= 0 {

     

       110
       110
       +
       			offset = o

     

       111
       111
       +
       		}

     

       112
       112
       +
       	}

     

       113
       113
       +
       

     

       114
       114
       +
       	query := `select key, did, created from public_keys order by created desc limit ? offset ?`

     

       115
       115
       +
       	rows, err := d.db.Query(query, limit+1, offset) // +1 to check if there are more results

     

       116
       116
       +
       	if err != nil {

     

       117
       117
       +
       		return nil, "", err

     

       118
       118
       +
       	}

     

       119
       119
       +
       	defer rows.Close()

     

       120
       120
       +
       

     

       121
       121
       +
       	for rows.Next() {

     

       122
       122
       +
       		var publicKey PublicKey

     

       123
       123
       +
       		if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.CreatedAt); err != nil {

     

       124
       124
       +
       			return nil, "", err

     

       125
       125
       +
       		}

     

       126
       126
       +
       		keys = append(keys, publicKey)

     

       127
       127
       +
       	}

     

       128
       128
       +
       

     

       129
       129
       +
       	if err := rows.Err(); err != nil {

     

       130
       130
       +
       		return nil, "", err

     

       131
       131
       +
       	}

     

       132
       132
       +
       

     

       133
       133
       +
       	// check if there are more results for pagination

     

       134
       134
       +
       	var nextCursor string

     

       135
       135
       +
       	if len(keys) > limit {

     

       136
       136
       +
       		keys = keys[:limit] // remove the extra item

     

       137
       137
       +
       		nextCursor = strconv.Itoa(offset + limit)

     

       138
       138
       +
       	}

     

       139
       139
       +
       

     

       140
       140
       +
       	return keys, nextCursor, nil

     

       141
       141
       +
       }

knotserver/ingester.go

···

       98
       98
        
       	l := log.FromContext(ctx)

     

       99
       99
        
       	l = l.With("handler", "processPull")

     

       100
       100
        
       	l = l.With("did", did)

     

       101
       101
       +
       

     

       102
       102
       +
       	if record.Target == nil {

     

       103
       103
       +
       		return fmt.Errorf("ignoring pull record: target repo is nil")

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       101
       106
        
       	l = l.With("target_repo", record.Target.Repo)

     

       102
       107
        
       	l = l.With("target_branch", record.Target.Branch)

     

       103
       108

+58

knotserver/xrpc/list_keys.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"strconv"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       9
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       func (x *Xrpc) ListKeys(w http.ResponseWriter, r *http.Request) {

     

       13
       13
       +
       	cursor := r.URL.Query().Get("cursor")

     

       14
       14
       +
       

     

       15
       15
       +
       	limit := 100 // default

     

       16
       16
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       17
       17
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 1000 {

     

       18
       18
       +
       			limit = l

     

       19
       19
       +
       		}

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	keys, nextCursor, err := x.Db.GetPublicKeysPaginated(limit, cursor)

     

       23
       23
       +
       	if err != nil {

     

       24
       24
       +
       		x.Logger.Error("failed to get public keys", "error", err)

     

       25
       25
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       26
       26
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       27
       27
       +
       			xrpcerr.WithMessage("failed to retrieve public keys"),

     

       28
       28
       +
       		), http.StatusInternalServerError)

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	publicKeys := make([]*tangled.KnotListKeys_PublicKey, 0, len(keys))

     

       33
       33
       +
       	for _, key := range keys {

     

       34
       34
       +
       		publicKeys = append(publicKeys, &tangled.KnotListKeys_PublicKey{

     

       35
       35
       +
       			Did:       key.Did,

     

       36
       36
       +
       			Key:       key.Key,

     

       37
       37
       +
       			CreatedAt: key.CreatedAt,

     

       38
       38
       +
       		})

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	response := tangled.KnotListKeys_Output{

     

       42
       42
       +
       		Keys: publicKeys,

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	if nextCursor != "" {

     

       46
       46
       +
       		response.Cursor = &nextCursor

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	w.Header().Set("Content-Type", "application/json")

     

       50
       50
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       51
       51
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       52
       52
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       53
       53
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       54
       54
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       55
       55
       +
       		), http.StatusInternalServerError)

     

       56
       56
       +
       		return

     

       57
       57
       +
       	}

     

       58
       58
       +
       }

+80

knotserver/xrpc/repo_archive.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"compress/gzip"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       

     

       9
       9
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       10
       10
       +
       

     

       11
       11
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       12
       12
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       13
       13
       +
       )

     

       14
       14
       +
       

     

       15
       15
       +
       func (x *Xrpc) RepoArchive(w http.ResponseWriter, r *http.Request) {

     

       16
       16
       +
       	repo, repoPath, unescapedRef, err := x.parseStandardParams(r)

     

       17
       17
       +
       	if err != nil {

     

       18
       18
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       19
       19
       +
       		return

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	format := r.URL.Query().Get("format")

     

       23
       23
       +
       	if format == "" {

     

       24
       24
       +
       		format = "tar.gz" // default

     

       25
       25
       +
       	}

     

       26
       26
       +
       

     

       27
       27
       +
       	prefix := r.URL.Query().Get("prefix")

     

       28
       28
       +
       

     

       29
       29
       +
       	if format != "tar.gz" {

     

       30
       30
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       31
       31
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       32
       32
       +
       			xrpcerr.WithMessage("only tar.gz format is supported"),

     

       33
       33
       +
       		), http.StatusBadRequest)

     

       34
       34
       +
       		return

     

       35
       35
       +
       	}

     

       36
       36
       +
       

     

       37
       37
       +
       	gr, err := git.Open(repoPath, unescapedRef)

     

       38
       38
       +
       	if err != nil {

     

       39
       39
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       40
       40
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       41
       41
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       42
       42
       +
       		), http.StatusNotFound)

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       45
       45
       +
       

     

       46
       46
       +
       	repoParts := strings.Split(repo, "/")

     

       47
       47
       +
       	repoName := repoParts[len(repoParts)-1]

     

       48
       48
       +
       

     

       49
       49
       +
       	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(unescapedRef).Short(), "/", "-")

     

       50
       50
       +
       

     

       51
       51
       +
       	var archivePrefix string

     

       52
       52
       +
       	if prefix != "" {

     

       53
       53
       +
       		archivePrefix = prefix

     

       54
       54
       +
       	} else {

     

       55
       55
       +
       		archivePrefix = fmt.Sprintf("%s-%s", repoName, safeRefFilename)

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	filename := fmt.Sprintf("%s-%s.tar.gz", repoName, safeRefFilename)

     

       59
       59
       +
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))

     

       60
       60
       +
       	w.Header().Set("Content-Type", "application/gzip")

     

       61
       61
       +
       

     

       62
       62
       +
       	gw := gzip.NewWriter(w)

     

       63
       63
       +
       	defer gw.Close()

     

       64
       64
       +
       

     

       65
       65
       +
       	err = gr.WriteTar(gw, archivePrefix)

     

       66
       66
       +
       	if err != nil {

     

       67
       67
       +
       		// once we start writing to the body we can't report error anymore

     

       68
       68
       +
       		// so we are only left with logging the error

     

       69
       69
       +
       		x.Logger.Error("writing tar file", "error", err.Error())

     

       70
       70
       +
       		return

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	err = gw.Flush()

     

       74
       74
       +
       	if err != nil {

     

       75
       75
       +
       		// once we start writing to the body we can't report error anymore

     

       76
       76
       +
       		// so we are only left with logging the error

     

       77
       77
       +
       		x.Logger.Error("flushing", "error", err.Error())

     

       78
       78
       +
       		return

     

       79
       79
       +
       	}

     

       80
       80
       +
       }

+150

knotserver/xrpc/repo_blob.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"crypto/sha256"

     

       5
       5
       +
       	"encoding/base64"

     

       6
       6
       +
       	"encoding/json"

     

       7
       7
       +
       	"fmt"

     

       8
       8
       +
       	"net/http"

     

       9
       9
       +
       	"path/filepath"

     

       10
       10
       +
       	"slices"

     

       11
       11
       +
       	"strings"

     

       12
       12
       +
       

     

       13
       13
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       14
       14
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       15
       15
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       16
       16
       +
       )

     

       17
       17
       +
       

     

       18
       18
       +
       func (x *Xrpc) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       19
       19
       +
       	_, repoPath, ref, err := x.parseStandardParams(r)

     

       20
       20
       +
       	if err != nil {

     

       21
       21
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       22
       22
       +
       		return

     

       23
       23
       +
       	}

     

       24
       24
       +
       

     

       25
       25
       +
       	treePath := r.URL.Query().Get("path")

     

       26
       26
       +
       	if treePath == "" {

     

       27
       27
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       28
       28
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       29
       29
       +
       			xrpcerr.WithMessage("missing path parameter"),

     

       30
       30
       +
       		), http.StatusBadRequest)

     

       31
       31
       +
       		return

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	raw := r.URL.Query().Get("raw") == "true"

     

       35
       35
       +
       

     

       36
       36
       +
       	gr, err := git.Open(repoPath, ref)

     

       37
       37
       +
       	if err != nil {

     

       38
       38
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       39
       39
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       40
       40
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       41
       41
       +
       		), http.StatusNotFound)

     

       42
       42
       +
       		return

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	contents, err := gr.RawContent(treePath)

     

       46
       46
       +
       	if err != nil {

     

       47
       47
       +
       		x.Logger.Error("file content", "error", err.Error())

     

       48
       48
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       49
       49
       +
       			xrpcerr.WithTag("FileNotFound"),

     

       50
       50
       +
       			xrpcerr.WithMessage("file not found at the specified path"),

     

       51
       51
       +
       		), http.StatusNotFound)

     

       52
       52
       +
       		return

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	mimeType := http.DetectContentType(contents)

     

       56
       56
       +
       

     

       57
       57
       +
       	if filepath.Ext(treePath) == ".svg" {

     

       58
       58
       +
       		mimeType = "image/svg+xml"

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	if raw {

     

       62
       62
       +
       		contentHash := sha256.Sum256(contents)

     

       63
       63
       +
       		eTag := fmt.Sprintf("\"%x\"", contentHash)

     

       64
       64
       +
       

     

       65
       65
       +
       		switch {

     

       66
       66
       +
       		case strings.HasPrefix(mimeType, "image/"), strings.HasPrefix(mimeType, "video/"):

     

       67
       67
       +
       			if clientETag := r.Header.Get("If-None-Match"); clientETag == eTag {

     

       68
       68
       +
       				w.WriteHeader(http.StatusNotModified)

     

       69
       69
       +
       				return

     

       70
       70
       +
       			}

     

       71
       71
       +
       			w.Header().Set("ETag", eTag)

     

       72
       72
       +
       

     

       73
       73
       +
       		case strings.HasPrefix(mimeType, "text/"):

     

       74
       74
       +
       			w.Header().Set("Cache-Control", "public, no-cache")

     

       75
       75
       +
       			// serve all text content as text/plain

     

       76
       76
       +
       			w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       77
       77
       +
       

     

       78
       78
       +
       		case isTextualMimeType(mimeType):

     

       79
       79
       +
       			// handle textual application types (json, xml, etc.) as text/plain

     

       80
       80
       +
       			w.Header().Set("Cache-Control", "public, no-cache")

     

       81
       81
       +
       			w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       82
       82
       +
       

     

       83
       83
       +
       		default:

     

       84
       84
       +
       			x.Logger.Error("attempted to serve disallowed file type", "mimetype", mimeType)

     

       85
       85
       +
       			writeError(w, xrpcerr.NewXrpcError(

     

       86
       86
       +
       				xrpcerr.WithTag("InvalidRequest"),

     

       87
       87
       +
       				xrpcerr.WithMessage("only image, video, and text files can be accessed directly"),

     

       88
       88
       +
       			), http.StatusForbidden)

     

       89
       89
       +
       			return

     

       90
       90
       +
       		}

     

       91
       91
       +
       		w.Write(contents)

     

       92
       92
       +
       		return

     

       93
       93
       +
       	}

     

       94
       94
       +
       

     

       95
       95
       +
       	isTextual := func(mt string) bool {

     

       96
       96
       +
       		return strings.HasPrefix(mt, "text/") || isTextualMimeType(mt)

     

       97
       97
       +
       	}

     

       98
       98
       +
       

     

       99
       99
       +
       	var content string

     

       100
       100
       +
       	var encoding string

     

       101
       101
       +
       

     

       102
       102
       +
       	isBinary := !isTextual(mimeType)

     

       103
       103
       +
       

     

       104
       104
       +
       	if isBinary {

     

       105
       105
       +
       		content = base64.StdEncoding.EncodeToString(contents)

     

       106
       106
       +
       		encoding = "base64"

     

       107
       107
       +
       	} else {

     

       108
       108
       +
       		content = string(contents)

     

       109
       109
       +
       		encoding = "utf-8"

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	response := tangled.RepoBlob_Output{

     

       113
       113
       +
       		Ref:      ref,

     

       114
       114
       +
       		Path:     treePath,

     

       115
       115
       +
       		Content:  content,

     

       116
       116
       +
       		Encoding: &encoding,

     

       117
       117
       +
       		Size:     &[]int64{int64(len(contents))}[0],

     

       118
       118
       +
       		IsBinary: &isBinary,

     

       119
       119
       +
       	}

     

       120
       120
       +
       

     

       121
       121
       +
       	if mimeType != "" {

     

       122
       122
       +
       		response.MimeType = &mimeType

     

       123
       123
       +
       	}

     

       124
       124
       +
       

     

       125
       125
       +
       	w.Header().Set("Content-Type", "application/json")

     

       126
       126
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       127
       127
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       128
       128
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       129
       129
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       130
       130
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       131
       131
       +
       		), http.StatusInternalServerError)

     

       132
       132
       +
       		return

     

       133
       133
       +
       	}

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       // isTextualMimeType returns true if the MIME type represents textual content

     

       137
       137
       +
       // that should be served as text/plain for security reasons

     

       138
       138
       +
       func isTextualMimeType(mimeType string) bool {

     

       139
       139
       +
       	textualTypes := []string{

     

       140
       140
       +
       		"application/json",

     

       141
       141
       +
       		"application/xml",

     

       142
       142
       +
       		"application/yaml",

     

       143
       143
       +
       		"application/x-yaml",

     

       144
       144
       +
       		"application/toml",

     

       145
       145
       +
       		"application/javascript",

     

       146
       146
       +
       		"application/ecmascript",

     

       147
       147
       +
       	}

     

       148
       148
       +
       

     

       149
       149
       +
       	return slices.Contains(textualTypes, mimeType)

     

       150
       150
       +
       }

+96

knotserver/xrpc/repo_branch.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       10
       10
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func (x *Xrpc) RepoBranch(w http.ResponseWriter, r *http.Request) {

     

       14
       14
       +
       	repo := r.URL.Query().Get("repo")

     

       15
       15
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       16
       16
       +
       	if err != nil {

     

       17
       17
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       18
       18
       +
       		return

     

       19
       19
       +
       	}

     

       20
       20
       +
       

     

       21
       21
       +
       	name := r.URL.Query().Get("name")

     

       22
       22
       +
       	if name == "" {

     

       23
       23
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       24
       24
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       25
       25
       +
       			xrpcerr.WithMessage("missing name parameter"),

     

       26
       26
       +
       		), http.StatusBadRequest)

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	branchName, _ := url.PathUnescape(name)

     

       31
       31
       +
       

     

       32
       32
       +
       	gr, err := git.PlainOpen(repoPath)

     

       33
       33
       +
       	if err != nil {

     

       34
       34
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       35
       35
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       36
       36
       +
       			xrpcerr.WithMessage("repository not found"),

     

       37
       37
       +
       		), http.StatusNotFound)

     

       38
       38
       +
       		return

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	ref, err := gr.Branch(branchName)

     

       42
       42
       +
       	if err != nil {

     

       43
       43
       +
       		x.Logger.Error("getting branch", "error", err.Error())

     

       44
       44
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       45
       45
       +
       			xrpcerr.WithTag("BranchNotFound"),

     

       46
       46
       +
       			xrpcerr.WithMessage("branch not found"),

     

       47
       47
       +
       		), http.StatusNotFound)

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

       51
       51
       +
       	commit, err := gr.Commit(ref.Hash())

     

       52
       52
       +
       	if err != nil {

     

       53
       53
       +
       		x.Logger.Error("getting commit object", "error", err.Error())

     

       54
       54
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       55
       55
       +
       			xrpcerr.WithTag("BranchNotFound"),

     

       56
       56
       +
       			xrpcerr.WithMessage("failed to get commit object"),

     

       57
       57
       +
       		), http.StatusInternalServerError)

     

       58
       58
       +
       		return

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	defaultBranch, err := gr.FindMainBranch()

     

       62
       62
       +
       	isDefault := false

     

       63
       63
       +
       	if err != nil {

     

       64
       64
       +
       		x.Logger.Error("getting default branch", "error", err.Error())

     

       65
       65
       +
       	} else if defaultBranch == branchName {

     

       66
       66
       +
       		isDefault = true

     

       67
       67
       +
       	}

     

       68
       68
       +
       

     

       69
       69
       +
       	response := tangled.RepoBranch_Output{

     

       70
       70
       +
       		Name:      ref.Name().Short(),

     

       71
       71
       +
       		Hash:      ref.Hash().String(),

     

       72
       72
       +
       		ShortHash: &[]string{ref.Hash().String()[:7]}[0],

     

       73
       73
       +
       		When:      commit.Author.When.Format("2006-01-02T15:04:05.000Z"),

     

       74
       74
       +
       		IsDefault: &isDefault,

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	if commit.Message != "" {

     

       78
       78
       +
       		response.Message = &commit.Message

     

       79
       79
       +
       	}

     

       80
       80
       +
       

     

       81
       81
       +
       	response.Author = &tangled.RepoBranch_Signature{

     

       82
       82
       +
       		Name:  commit.Author.Name,

     

       83
       83
       +
       		Email: commit.Author.Email,

     

       84
       84
       +
       		When:  commit.Author.When.Format("2006-01-02T15:04:05.000Z"),

     

       85
       85
       +
       	}

     

       86
       86
       +
       

     

       87
       87
       +
       	w.Header().Set("Content-Type", "application/json")

     

       88
       88
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       89
       89
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       90
       90
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       91
       91
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       92
       92
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       93
       93
       +
       		), http.StatusInternalServerError)

     

       94
       94
       +
       		return

     

       95
       95
       +
       	}

     

       96
       96
       +
       }

+70

knotserver/xrpc/repo_branches.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"strconv"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/types"

     

       10
       10
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func (x *Xrpc) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       14
       14
       +
       	repo := r.URL.Query().Get("repo")

     

       15
       15
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       16
       16
       +
       	if err != nil {

     

       17
       17
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       18
       18
       +
       		return

     

       19
       19
       +
       	}

     

       20
       20
       +
       

     

       21
       21
       +
       	cursor := r.URL.Query().Get("cursor")

     

       22
       22
       +
       

     

       23
       23
       +
       	limit := 50 // default

     

       24
       24
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       25
       25
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {

     

       26
       26
       +
       			limit = l

     

       27
       27
       +
       		}

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	gr, err := git.PlainOpen(repoPath)

     

       31
       31
       +
       	if err != nil {

     

       32
       32
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       33
       33
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       34
       34
       +
       			xrpcerr.WithMessage("repository not found"),

     

       35
       35
       +
       		), http.StatusNotFound)

     

       36
       36
       +
       		return

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	branches, _ := gr.Branches()

     

       40
       40
       +
       

     

       41
       41
       +
       	offset := 0

     

       42
       42
       +
       	if cursor != "" {

     

       43
       43
       +
       		if o, err := strconv.Atoi(cursor); err == nil && o >= 0 && o < len(branches) {

     

       44
       44
       +
       			offset = o

     

       45
       45
       +
       		}

     

       46
       46
       +
       	}

     

       47
       47
       +
       

     

       48
       48
       +
       	end := offset + limit

     

       49
       49
       +
       	if end > len(branches) {

     

       50
       50
       +
       		end = len(branches)

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	paginatedBranches := branches[offset:end]

     

       54
       54
       +
       

     

       55
       55
       +
       	// Create response using existing types.RepoBranchesResponse

     

       56
       56
       +
       	response := types.RepoBranchesResponse{

     

       57
       57
       +
       		Branches: paginatedBranches,

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	// Write JSON response directly

     

       61
       61
       +
       	w.Header().Set("Content-Type", "application/json")

     

       62
       62
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       63
       63
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       64
       64
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       65
       65
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       66
       66
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       67
       67
       +
       		), http.StatusInternalServerError)

     

       68
       68
       +
       		return

     

       69
       69
       +
       	}

     

       70
       70
       +
       }

+98

knotserver/xrpc/repo_compare.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       10
       10
       +
       	"tangled.sh/tangled.sh/core/types"

     

       11
       11
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       func (x *Xrpc) RepoCompare(w http.ResponseWriter, r *http.Request) {

     

       15
       15
       +
       	repo := r.URL.Query().Get("repo")

     

       16
       16
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       17
       17
       +
       	if err != nil {

     

       18
       18
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       19
       19
       +
       		return

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	rev1Param := r.URL.Query().Get("rev1")

     

       23
       23
       +
       	if rev1Param == "" {

     

       24
       24
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       25
       25
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       26
       26
       +
       			xrpcerr.WithMessage("missing rev1 parameter"),

     

       27
       27
       +
       		), http.StatusBadRequest)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	rev2Param := r.URL.Query().Get("rev2")

     

       32
       32
       +
       	if rev2Param == "" {

     

       33
       33
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       34
       34
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       35
       35
       +
       			xrpcerr.WithMessage("missing rev2 parameter"),

     

       36
       36
       +
       		), http.StatusBadRequest)

     

       37
       37
       +
       		return

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	rev1, _ := url.PathUnescape(rev1Param)

     

       41
       41
       +
       	rev2, _ := url.PathUnescape(rev2Param)

     

       42
       42
       +
       

     

       43
       43
       +
       	gr, err := git.PlainOpen(repoPath)

     

       44
       44
       +
       	if err != nil {

     

       45
       45
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       46
       46
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       47
       47
       +
       			xrpcerr.WithMessage("repository not found"),

     

       48
       48
       +
       		), http.StatusNotFound)

     

       49
       49
       +
       		return

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	commit1, err := gr.ResolveRevision(rev1)

     

       53
       53
       +
       	if err != nil {

     

       54
       54
       +
       		x.Logger.Error("error resolving revision 1", "msg", err.Error())

     

       55
       55
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       56
       56
       +
       			xrpcerr.WithTag("RevisionNotFound"),

     

       57
       57
       +
       			xrpcerr.WithMessage(fmt.Sprintf("error resolving revision %s", rev1)),

     

       58
       58
       +
       		), http.StatusBadRequest)

     

       59
       59
       +
       		return

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	commit2, err := gr.ResolveRevision(rev2)

     

       63
       63
       +
       	if err != nil {

     

       64
       64
       +
       		x.Logger.Error("error resolving revision 2", "msg", err.Error())

     

       65
       65
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       66
       66
       +
       			xrpcerr.WithTag("RevisionNotFound"),

     

       67
       67
       +
       			xrpcerr.WithMessage(fmt.Sprintf("error resolving revision %s", rev2)),

     

       68
       68
       +
       		), http.StatusBadRequest)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

       72
       72
       +
       	rawPatch, formatPatch, err := gr.FormatPatch(commit1, commit2)

     

       73
       73
       +
       	if err != nil {

     

       74
       74
       +
       		x.Logger.Error("error comparing revisions", "msg", err.Error())

     

       75
       75
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       76
       76
       +
       			xrpcerr.WithTag("CompareError"),

     

       77
       77
       +
       			xrpcerr.WithMessage("error comparing revisions"),

     

       78
       78
       +
       		), http.StatusBadRequest)

     

       79
       79
       +
       		return

     

       80
       80
       +
       	}

     

       81
       81
       +
       

     

       82
       82
       +
       	resp := types.RepoFormatPatchResponse{

     

       83
       83
       +
       		Rev1:        commit1.Hash.String(),

     

       84
       84
       +
       		Rev2:        commit2.Hash.String(),

     

       85
       85
       +
       		FormatPatch: formatPatch,

     

       86
       86
       +
       		Patch:       rawPatch,

     

       87
       87
       +
       	}

     

       88
       88
       +
       

     

       89
       89
       +
       	w.Header().Set("Content-Type", "application/json")

     

       90
       90
       +
       	if err := json.NewEncoder(w).Encode(resp); err != nil {

     

       91
       91
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       92
       92
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       93
       93
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       94
       94
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       95
       95
       +
       		), http.StatusInternalServerError)

     

       96
       96
       +
       		return

     

       97
       97
       +
       	}

     

       98
       98
       +
       }

+65

knotserver/xrpc/repo_diff.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/types"

     

       10
       10
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       11
       11
       +
       )

     

       12
       12
       +
       

     

       13
       13
       +
       func (x *Xrpc) RepoDiff(w http.ResponseWriter, r *http.Request) {

     

       14
       14
       +
       	repo := r.URL.Query().Get("repo")

     

       15
       15
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       16
       16
       +
       	if err != nil {

     

       17
       17
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       18
       18
       +
       		return

     

       19
       19
       +
       	}

     

       20
       20
       +
       

     

       21
       21
       +
       	refParam := r.URL.Query().Get("ref")

     

       22
       22
       +
       	if refParam == "" {

     

       23
       23
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       24
       24
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       25
       25
       +
       			xrpcerr.WithMessage("missing ref parameter"),

     

       26
       26
       +
       		), http.StatusBadRequest)

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	ref, _ := url.QueryUnescape(refParam)

     

       31
       31
       +
       

     

       32
       32
       +
       	gr, err := git.Open(repoPath, ref)

     

       33
       33
       +
       	if err != nil {

     

       34
       34
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       35
       35
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       36
       36
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       37
       37
       +
       		), http.StatusNotFound)

     

       38
       38
       +
       		return

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	diff, err := gr.Diff()

     

       42
       42
       +
       	if err != nil {

     

       43
       43
       +
       		x.Logger.Error("getting diff", "error", err.Error())

     

       44
       44
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       45
       45
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       46
       46
       +
       			xrpcerr.WithMessage("failed to generate diff"),

     

       47
       47
       +
       		), http.StatusInternalServerError)

     

       48
       48
       +
       		return

     

       49
       49
       +
       	}

     

       50
       50
       +
       

     

       51
       51
       +
       	resp := types.RepoCommitResponse{

     

       52
       52
       +
       		Ref:  ref,

     

       53
       53
       +
       		Diff: diff,

     

       54
       54
       +
       	}

     

       55
       55
       +
       

     

       56
       56
       +
       	w.Header().Set("Content-Type", "application/json")

     

       57
       57
       +
       	if err := json.NewEncoder(w).Encode(resp); err != nil {

     

       58
       58
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       59
       59
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       60
       60
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       61
       61
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       62
       62
       +
       		), http.StatusInternalServerError)

     

       63
       63
       +
       		return

     

       64
       64
       +
       	}

     

       65
       65
       +
       }

+54

knotserver/xrpc/repo_get_default_branch.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       

     

       7
       7
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       8
       8
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       9
       9
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       10
       10
       +
       )

     

       11
       11
       +
       

     

       12
       12
       +
       func (x *Xrpc) RepoGetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       13
       13
       +
       	repo := r.URL.Query().Get("repo")

     

       14
       14
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       15
       15
       +
       	if err != nil {

     

       16
       16
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       17
       17
       +
       		return

     

       18
       18
       +
       	}

     

       19
       19
       +
       

     

       20
       20
       +
       	gr, err := git.Open(repoPath, "")

     

       21
       21
       +
       	if err != nil {

     

       22
       22
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       23
       23
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       24
       24
       +
       			xrpcerr.WithMessage("repository not found"),

     

       25
       25
       +
       		), http.StatusNotFound)

     

       26
       26
       +
       		return

     

       27
       27
       +
       	}

     

       28
       28
       +
       

     

       29
       29
       +
       	branch, err := gr.FindMainBranch()

     

       30
       30
       +
       	if err != nil {

     

       31
       31
       +
       		x.Logger.Error("getting default branch", "error", err.Error())

     

       32
       32
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       33
       33
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       34
       34
       +
       			xrpcerr.WithMessage("failed to get default branch"),

     

       35
       35
       +
       		), http.StatusInternalServerError)

     

       36
       36
       +
       		return

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	response := tangled.RepoGetDefaultBranch_Output{

     

       40
       40
       +
       		Name: branch,

     

       41
       41
       +
       		Hash: "",

     

       42
       42
       +
       		When: "1970-01-01T00:00:00.000Z",

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	w.Header().Set("Content-Type", "application/json")

     

       46
       46
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       47
       47
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       48
       48
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       49
       49
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       50
       50
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       51
       51
       +
       		), http.StatusInternalServerError)

     

       52
       52
       +
       		return

     

       53
       53
       +
       	}

     

       54
       54
       +
       }

+93

knotserver/xrpc/repo_languages.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"context"

     

       5
       5
       +
       	"encoding/json"

     

       6
       6
       +
       	"math"

     

       7
       7
       +
       	"net/http"

     

       8
       8
       +
       	"net/url"

     

       9
       9
       +
       	"time"

     

       10
       10
       +
       

     

       11
       11
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       12
       12
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       13
       13
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       func (x *Xrpc) RepoLanguages(w http.ResponseWriter, r *http.Request) {

     

       17
       17
       +
       	refParam := r.URL.Query().Get("ref")

     

       18
       18
       +
       	if refParam == "" {

     

       19
       19
       +
       		refParam = "HEAD" // default

     

       20
       20
       +
       	}

     

       21
       21
       +
       	ref, _ := url.PathUnescape(refParam)

     

       22
       22
       +
       

     

       23
       23
       +
       	repo := r.URL.Query().Get("repo")

     

       24
       24
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       25
       25
       +
       	if err != nil {

     

       26
       26
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	gr, err := git.Open(repoPath, ref)

     

       31
       31
       +
       	if err != nil {

     

       32
       32
       +
       		x.Logger.Error("opening repo", "error", err.Error())

     

       33
       33
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       34
       34
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       35
       35
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       36
       36
       +
       		), http.StatusNotFound)

     

       37
       37
       +
       		return

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)

     

       41
       41
       +
       	defer cancel()

     

       42
       42
       +
       

     

       43
       43
       +
       	sizes, err := gr.AnalyzeLanguages(ctx)

     

       44
       44
       +
       	if err != nil {

     

       45
       45
       +
       		x.Logger.Error("failed to analyze languages", "error", err.Error())

     

       46
       46
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       47
       47
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       48
       48
       +
       			xrpcerr.WithMessage("failed to analyze repository languages"),

     

       49
       49
       +
       		), http.StatusNoContent)

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       

     

       53
       53
       +
       	var apiLanguages []*tangled.RepoLanguages_Language

     

       54
       54
       +
       	var totalSize int64

     

       55
       55
       +
       

     

       56
       56
       +
       	for _, size := range sizes {

     

       57
       57
       +
       		totalSize += size

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

       60
       60
       +
       	for name, size := range sizes {

     

       61
       61
       +
       		percentagef64 := float64(size) / float64(totalSize) * 100

     

       62
       62
       +
       		percentage := math.Round(percentagef64)

     

       63
       63
       +
       

     

       64
       64
       +
       		lang := &tangled.RepoLanguages_Language{

     

       65
       65
       +
       			Name:       name,

     

       66
       66
       +
       			Size:       size,

     

       67
       67
       +
       			Percentage: int64(percentage),

     

       68
       68
       +
       		}

     

       69
       69
       +
       

     

       70
       70
       +
       		apiLanguages = append(apiLanguages, lang)

     

       71
       71
       +
       	}

     

       72
       72
       +
       

     

       73
       73
       +
       	response := tangled.RepoLanguages_Output{

     

       74
       74
       +
       		Ref:       ref,

     

       75
       75
       +
       		Languages: apiLanguages,

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	if totalSize > 0 {

     

       79
       79
       +
       		response.TotalSize = &totalSize

     

       80
       80
       +
       		totalFiles := int64(len(sizes))

     

       81
       81
       +
       		response.TotalFiles = &totalFiles

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	w.Header().Set("Content-Type", "application/json")

     

       85
       85
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       86
       86
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       87
       87
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       88
       88
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       89
       89
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       90
       90
       +
       		), http.StatusInternalServerError)

     

       91
       91
       +
       		return

     

       92
       92
       +
       	}

     

       93
       93
       +
       }

+101

knotserver/xrpc/repo_log.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"strconv"

     

       8
       8
       +
       

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       10
       10
       +
       	"tangled.sh/tangled.sh/core/types"

     

       11
       11
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       func (x *Xrpc) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       15
       15
       +
       	repo := r.URL.Query().Get("repo")

     

       16
       16
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       17
       17
       +
       	if err != nil {

     

       18
       18
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       19
       19
       +
       		return

     

       20
       20
       +
       	}

     

       21
       21
       +
       

     

       22
       22
       +
       	refParam := r.URL.Query().Get("ref")

     

       23
       23
       +
       	if refParam == "" {

     

       24
       24
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       25
       25
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       26
       26
       +
       			xrpcerr.WithMessage("missing ref parameter"),

     

       27
       27
       +
       		), http.StatusBadRequest)

     

       28
       28
       +
       		return

     

       29
       29
       +
       	}

     

       30
       30
       +
       

     

       31
       31
       +
       	path := r.URL.Query().Get("path")

     

       32
       32
       +
       	cursor := r.URL.Query().Get("cursor")

     

       33
       33
       +
       

     

       34
       34
       +
       	limit := 50 // default

     

       35
       35
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       36
       36
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {

     

       37
       37
       +
       			limit = l

     

       38
       38
       +
       		}

     

       39
       39
       +
       	}

     

       40
       40
       +
       

     

       41
       41
       +
       	ref, err := url.QueryUnescape(refParam)

     

       42
       42
       +
       	if err != nil {

     

       43
       43
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       44
       44
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       45
       45
       +
       			xrpcerr.WithMessage("invalid ref parameter"),

     

       46
       46
       +
       		), http.StatusBadRequest)

     

       47
       47
       +
       		return

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       50
       50
       +
       	gr, err := git.Open(repoPath, ref)

     

       51
       51
       +
       	if err != nil {

     

       52
       52
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       53
       53
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       54
       54
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       55
       55
       +
       		), http.StatusNotFound)

     

       56
       56
       +
       		return

     

       57
       57
       +
       	}

     

       58
       58
       +
       

     

       59
       59
       +
       	offset := 0

     

       60
       60
       +
       	if cursor != "" {

     

       61
       61
       +
       		if o, err := strconv.Atoi(cursor); err == nil && o >= 0 {

     

       62
       62
       +
       			offset = o

     

       63
       63
       +
       		}

     

       64
       64
       +
       	}

     

       65
       65
       +
       

     

       66
       66
       +
       	commits, err := gr.Commits(offset, limit)

     

       67
       67
       +
       	if err != nil {

     

       68
       68
       +
       		x.Logger.Error("fetching commits", "error", err.Error())

     

       69
       69
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       70
       70
       +
       			xrpcerr.WithTag("PathNotFound"),

     

       71
       71
       +
       			xrpcerr.WithMessage("failed to read commit log"),

     

       72
       72
       +
       		), http.StatusNotFound)

     

       73
       73
       +
       		return

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	// Create response using existing types.RepoLogResponse

     

       77
       77
       +
       	response := types.RepoLogResponse{

     

       78
       78
       +
       		Commits: commits,

     

       79
       79
       +
       		Ref:     ref,

     

       80
       80
       +
       		Page:    (offset / limit) + 1,

     

       81
       81
       +
       		PerPage: limit,

     

       82
       82
       +
       		Total:   len(commits), // This is not accurate for pagination, but matches existing behavior

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       85
       85
       +
       	if path != "" {

     

       86
       86
       +
       		response.Description = path

     

       87
       87
       +
       	}

     

       88
       88
       +
       

     

       89
       89
       +
       	response.Log = true

     

       90
       90
       +
       

     

       91
       91
       +
       	// Write JSON response directly

     

       92
       92
       +
       	w.Header().Set("Content-Type", "application/json")

     

       93
       93
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       94
       94
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       95
       95
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       96
       96
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       97
       97
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       98
       98
       +
       		), http.StatusInternalServerError)

     

       99
       99
       +
       		return

     

       100
       100
       +
       	}

     

       101
       101
       +
       }

+99

knotserver/xrpc/repo_tags.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"strconv"

     

       7
       7
       +
       

     

       8
       8
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       9
       9
       +
       	"github.com/go-git/go-git/v5/plumbing/object"

     

       10
       10
       +
       

     

       11
       11
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       12
       12
       +
       	"tangled.sh/tangled.sh/core/types"

     

       13
       13
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       14
       14
       +
       )

     

       15
       15
       +
       

     

       16
       16
       +
       func (x *Xrpc) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       17
       17
       +
       	repo := r.URL.Query().Get("repo")

     

       18
       18
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       19
       19
       +
       	if err != nil {

     

       20
       20
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       21
       21
       +
       		return

     

       22
       22
       +
       	}

     

       23
       23
       +
       

     

       24
       24
       +
       	cursor := r.URL.Query().Get("cursor")

     

       25
       25
       +
       

     

       26
       26
       +
       	limit := 50 // default

     

       27
       27
       +
       	if limitStr := r.URL.Query().Get("limit"); limitStr != "" {

     

       28
       28
       +
       		if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 100 {

     

       29
       29
       +
       			limit = l

     

       30
       30
       +
       		}

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	gr, err := git.Open(repoPath, "")

     

       34
       34
       +
       	if err != nil {

     

       35
       35
       +
       		x.Logger.Error("failed to open", "error", err)

     

       36
       36
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       37
       37
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       38
       38
       +
       			xrpcerr.WithMessage("repository not found"),

     

       39
       39
       +
       		), http.StatusNotFound)

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	tags, err := gr.Tags()

     

       44
       44
       +
       	if err != nil {

     

       45
       45
       +
       		x.Logger.Warn("getting tags", "error", err.Error())

     

       46
       46
       +
       		tags = []object.Tag{}

     

       47
       47
       +
       	}

     

       48
       48
       +
       

     

       49
       49
       +
       	rtags := []*types.TagReference{}

     

       50
       50
       +
       	for _, tag := range tags {

     

       51
       51
       +
       		var target *object.Tag

     

       52
       52
       +
       		if tag.Target != plumbing.ZeroHash {

     

       53
       53
       +
       			target = &tag

     

       54
       54
       +
       		}

     

       55
       55
       +
       		tr := types.TagReference{

     

       56
       56
       +
       			Tag: target,

     

       57
       57
       +
       		}

     

       58
       58
       +
       

     

       59
       59
       +
       		tr.Reference = types.Reference{

     

       60
       60
       +
       			Name: tag.Name,

     

       61
       61
       +
       			Hash: tag.Hash.String(),

     

       62
       62
       +
       		}

     

       63
       63
       +
       

     

       64
       64
       +
       		if tag.Message != "" {

     

       65
       65
       +
       			tr.Message = tag.Message

     

       66
       66
       +
       		}

     

       67
       67
       +
       

     

       68
       68
       +
       		rtags = append(rtags, &tr)

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	// apply pagination manually

     

       72
       72
       +
       	offset := 0

     

       73
       73
       +
       	if cursor != "" {

     

       74
       74
       +
       		if o, err := strconv.Atoi(cursor); err == nil && o >= 0 && o < len(rtags) {

     

       75
       75
       +
       			offset = o

     

       76
       76
       +
       		}

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       79
       79
       +
       	// calculate end index

     

       80
       80
       +
       	end := min(offset+limit, len(rtags))

     

       81
       81
       +
       

     

       82
       82
       +
       	paginatedTags := rtags[offset:end]

     

       83
       83
       +
       

     

       84
       84
       +
       	// Create response using existing types.RepoTagsResponse

     

       85
       85
       +
       	response := types.RepoTagsResponse{

     

       86
       86
       +
       		Tags: paginatedTags,

     

       87
       87
       +
       	}

     

       88
       88
       +
       

     

       89
       89
       +
       	// Write JSON response directly

     

       90
       90
       +
       	w.Header().Set("Content-Type", "application/json")

     

       91
       91
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       92
       92
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       93
       93
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       94
       94
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       95
       95
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       96
       96
       +
       		), http.StatusInternalServerError)

     

       97
       97
       +
       		return

     

       98
       98
       +
       	}

     

       99
       99
       +
       }

+116

knotserver/xrpc/repo_tree.go

···

       1
       1
       +
       package xrpc

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"path/filepath"

     

       8
       8
       +
       

     

       9
       9
       +
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       10
       10
       +
       	"tangled.sh/tangled.sh/core/knotserver/git"

     

       11
       11
       +
       	xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"

     

       12
       12
       +
       )

     

       13
       13
       +
       

     

       14
       14
       +
       func (x *Xrpc) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       15
       15
       +
       	ctx := r.Context()

     

       16
       16
       +
       

     

       17
       17
       +
       	repo := r.URL.Query().Get("repo")

     

       18
       18
       +
       	repoPath, err := x.parseRepoParam(repo)

     

       19
       19
       +
       	if err != nil {

     

       20
       20
       +
       		writeError(w, err.(xrpcerr.XrpcError), http.StatusBadRequest)

     

       21
       21
       +
       		return

     

       22
       22
       +
       	}

     

       23
       23
       +
       

     

       24
       24
       +
       	refParam := r.URL.Query().Get("ref")

     

       25
       25
       +
       	if refParam == "" {

     

       26
       26
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       27
       27
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       28
       28
       +
       			xrpcerr.WithMessage("missing ref parameter"),

     

       29
       29
       +
       		), http.StatusBadRequest)

     

       30
       30
       +
       		return

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	path := r.URL.Query().Get("path")

     

       34
       34
       +
       	// path can be empty (defaults to root)

     

       35
       35
       +
       

     

       36
       36
       +
       	ref, err := url.QueryUnescape(refParam)

     

       37
       37
       +
       	if err != nil {

     

       38
       38
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       39
       39
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       40
       40
       +
       			xrpcerr.WithMessage("invalid ref parameter"),

     

       41
       41
       +
       		), http.StatusBadRequest)

     

       42
       42
       +
       		return

     

       43
       43
       +
       	}

     

       44
       44
       +
       

     

       45
       45
       +
       	gr, err := git.Open(repoPath, ref)

     

       46
       46
       +
       	if err != nil {

     

       47
       47
       +
       		x.Logger.Error("failed to open git repository", "error", err, "path", repoPath, "ref", ref)

     

       48
       48
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       49
       49
       +
       			xrpcerr.WithTag("RefNotFound"),

     

       50
       50
       +
       			xrpcerr.WithMessage("repository or ref not found"),

     

       51
       51
       +
       		), http.StatusNotFound)

     

       52
       52
       +
       		return

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	files, err := gr.FileTree(ctx, path)

     

       56
       56
       +
       	if err != nil {

     

       57
       57
       +
       		x.Logger.Error("failed to get file tree", "error", err, "path", path)

     

       58
       58
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       59
       59
       +
       			xrpcerr.WithTag("PathNotFound"),

     

       60
       60
       +
       			xrpcerr.WithMessage("failed to read repository tree"),

     

       61
       61
       +
       		), http.StatusNotFound)

     

       62
       62
       +
       		return

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	// convert NiceTree -> tangled.RepoTree_TreeEntry

     

       66
       66
       +
       	treeEntries := make([]*tangled.RepoTree_TreeEntry, len(files))

     

       67
       67
       +
       	for i, file := range files {

     

       68
       68
       +
       		entry := &tangled.RepoTree_TreeEntry{

     

       69
       69
       +
       			Name:       file.Name,

     

       70
       70
       +
       			Mode:       file.Mode,

     

       71
       71
       +
       			Size:       file.Size,

     

       72
       72
       +
       			Is_file:    file.IsFile,

     

       73
       73
       +
       			Is_subtree: file.IsSubtree,

     

       74
       74
       +
       		}

     

       75
       75
       +
       

     

       76
       76
       +
       		if file.LastCommit != nil {

     

       77
       77
       +
       			entry.Last_commit = &tangled.RepoTree_LastCommit{

     

       78
       78
       +
       				Hash:    file.LastCommit.Hash.String(),

     

       79
       79
       +
       				Message: file.LastCommit.Message,

     

       80
       80
       +
       				When:    file.LastCommit.When.Format("2006-01-02T15:04:05.000Z"),

     

       81
       81
       +
       			}

     

       82
       82
       +
       		}

     

       83
       83
       +
       

     

       84
       84
       +
       		treeEntries[i] = entry

     

       85
       85
       +
       	}

     

       86
       86
       +
       

     

       87
       87
       +
       	var parentPtr *string

     

       88
       88
       +
       	if path != "" {

     

       89
       89
       +
       		parentPtr = &path

     

       90
       90
       +
       	}

     

       91
       91
       +
       

     

       92
       92
       +
       	var dotdotPtr *string

     

       93
       93
       +
       	if path != "" {

     

       94
       94
       +
       		dotdot := filepath.Dir(path)

     

       95
       95
       +
       		if dotdot != "." {

     

       96
       96
       +
       			dotdotPtr = &dotdot

     

       97
       97
       +
       		}

     

       98
       98
       +
       	}

     

       99
       99
       +
       

     

       100
       100
       +
       	response := tangled.RepoTree_Output{

     

       101
       101
       +
       		Ref:    ref,

     

       102
       102
       +
       		Parent: parentPtr,

     

       103
       103
       +
       		Dotdot: dotdotPtr,

     

       104
       104
       +
       		Files:  treeEntries,

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

       107
       107
       +
       	w.Header().Set("Content-Type", "application/json")

     

       108
       108
       +
       	if err := json.NewEncoder(w).Encode(response); err != nil {

     

       109
       109
       +
       		x.Logger.Error("failed to encode response", "error", err)

     

       110
       110
       +
       		writeError(w, xrpcerr.NewXrpcError(

     

       111
       111
       +
       			xrpcerr.WithTag("InternalServerError"),

     

       112
       112
       +
       			xrpcerr.WithMessage("failed to encode response"),

     

       113
       113
       +
       		), http.StatusInternalServerError)

     

       114
       114
       +
       		return

     

       115
       115
       +
       	}

     

       116
       116
       +
       }

+84

knotserver/xrpc/xrpc.go

···

       4
       4
        
       	"encoding/json"

     

       5
       5
        
       	"log/slog"

     

       6
       6
        
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"strings"

     

       7
       9
        
       

     

       10
       10
       +
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       8
       11
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       9
       12
        
       	"tangled.sh/tangled.sh/core/idresolver"

     

       10
       13
        
       	"tangled.sh/tangled.sh/core/jetstream"

     
···

       50
       53
        
       	// - we can calculate on PR submit/resubmit/gitRefUpdate etc.

     

       51
       54
        
       	// - use ETags on clients to keep requests to a minimum

     

       52
       55
        
       	r.Post("/"+tangled.RepoMergeCheckNSID, x.MergeCheck)

     

       56
       56
       +
       

     

       57
       57
       +
       	// repo query endpoints (no auth required)

     

       58
       58
       +
       	r.Get("/"+tangled.RepoTreeNSID, x.RepoTree)

     

       59
       59
       +
       	r.Get("/"+tangled.RepoLogNSID, x.RepoLog)

     

       60
       60
       +
       	r.Get("/"+tangled.RepoBranchesNSID, x.RepoBranches)

     

       61
       61
       +
       	r.Get("/"+tangled.RepoTagsNSID, x.RepoTags)

     

       62
       62
       +
       	r.Get("/"+tangled.RepoBlobNSID, x.RepoBlob)

     

       63
       63
       +
       	r.Get("/"+tangled.RepoDiffNSID, x.RepoDiff)

     

       64
       64
       +
       	r.Get("/"+tangled.RepoCompareNSID, x.RepoCompare)

     

       65
       65
       +
       	r.Get("/"+tangled.RepoGetDefaultBranchNSID, x.RepoGetDefaultBranch)

     

       66
       66
       +
       	r.Get("/"+tangled.RepoBranchNSID, x.RepoBranch)

     

       67
       67
       +
       	r.Get("/"+tangled.RepoArchiveNSID, x.RepoArchive)

     

       68
       68
       +
       	r.Get("/"+tangled.RepoLanguagesNSID, x.RepoLanguages)

     

       69
       69
       +
       

     

       70
       70
       +
       	// knot query endpoints (no auth required)

     

       71
       71
       +
       	r.Get("/"+tangled.KnotListKeysNSID, x.ListKeys)

     

       72
       72
       +
       

     

       53
       73
        
       	return r

     

       74
       74
       +
       }

     

       75
       75
       +
       

     

       76
       76
       +
       // parseRepoParam parses a repo parameter in 'did/repoName' format and returns

     

       77
       77
       +
       // the full repository path on disk

     

       78
       78
       +
       func (x *Xrpc) parseRepoParam(repo string) (string, error) {

     

       79
       79
       +
       	if repo == "" {

     

       80
       80
       +
       		return "", xrpcerr.NewXrpcError(

     

       81
       81
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       82
       82
       +
       			xrpcerr.WithMessage("missing repo parameter"),

     

       83
       83
       +
       		)

     

       84
       84
       +
       	}

     

       85
       85
       +
       

     

       86
       86
       +
       	// Parse repo string (did/repoName format)

     

       87
       87
       +
       	parts := strings.Split(repo, "/")

     

       88
       88
       +
       	if len(parts) < 2 {

     

       89
       89
       +
       		return "", xrpcerr.NewXrpcError(

     

       90
       90
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       91
       91
       +
       			xrpcerr.WithMessage("invalid repo format, expected 'did/repoName'"),

     

       92
       92
       +
       		)

     

       93
       93
       +
       	}

     

       94
       94
       +
       

     

       95
       95
       +
       	did := strings.Join(parts[:len(parts)-1], "/")

     

       96
       96
       +
       	repoName := parts[len(parts)-1]

     

       97
       97
       +
       

     

       98
       98
       +
       	// Construct repository path using the same logic as didPath

     

       99
       99
       +
       	didRepoPath, err := securejoin.SecureJoin(did, repoName)

     

       100
       100
       +
       	if err != nil {

     

       101
       101
       +
       		return "", xrpcerr.NewXrpcError(

     

       102
       102
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       103
       103
       +
       			xrpcerr.WithMessage("failed to access repository"),

     

       104
       104
       +
       		)

     

       105
       105
       +
       	}

     

       106
       106
       +
       

     

       107
       107
       +
       	repoPath, err := securejoin.SecureJoin(x.Config.Repo.ScanPath, didRepoPath)

     

       108
       108
       +
       	if err != nil {

     

       109
       109
       +
       		return "", xrpcerr.NewXrpcError(

     

       110
       110
       +
       			xrpcerr.WithTag("RepoNotFound"),

     

       111
       111
       +
       			xrpcerr.WithMessage("failed to access repository"),

     

       112
       112
       +
       		)

     

       113
       113
       +
       	}

     

       114
       114
       +
       

     

       115
       115
       +
       	return repoPath, nil

     

       116
       116
       +
       }

     

       117
       117
       +
       

     

       118
       118
       +
       // parseStandardParams parses common query parameters used by most handlers

     

       119
       119
       +
       func (x *Xrpc) parseStandardParams(r *http.Request) (repo, repoPath, ref string, err error) {

     

       120
       120
       +
       	// Parse repo parameter

     

       121
       121
       +
       	repo = r.URL.Query().Get("repo")

     

       122
       122
       +
       	repoPath, err = x.parseRepoParam(repo)

     

       123
       123
       +
       	if err != nil {

     

       124
       124
       +
       		return "", "", "", err

     

       125
       125
       +
       	}

     

       126
       126
       +
       

     

       127
       127
       +
       	// Parse and unescape ref parameter

     

       128
       128
       +
       	refParam := r.URL.Query().Get("ref")

     

       129
       129
       +
       	if refParam == "" {

     

       130
       130
       +
       		return "", "", "", xrpcerr.NewXrpcError(

     

       131
       131
       +
       			xrpcerr.WithTag("InvalidRequest"),

     

       132
       132
       +
       			xrpcerr.WithMessage("missing ref parameter"),

     

       133
       133
       +
       		)

     

       134
       134
       +
       	}

     

       135
       135
       +
       

     

       136
       136
       +
       	ref, _ = url.QueryUnescape(refParam)

     

       137
       137
       +
       	return repo, repoPath, ref, nil

     

       54
       138
        
       }

     

       55
       139
        
       

     

       56
       140
        
       func writeError(w http.ResponseWriter, e xrpcerr.XrpcError, status int) {