appview,knotmirror: use knotmirror to read the repository

Underlying types except the interface hasn't changed much.
Removed `xrpcclient.HandleXrpcErr()` call as appview always expect
knotmirror with compatible API.

Signed-off-by: Seongmin Lee <[e-mail]>

appview/config/config.go

···
 	Pds           PdsConfig       `env:",prefix=TANGLED_PDS_"`
 	Cloudflare    Cloudflare      `env:",prefix=TANGLED_CLOUDFLARE_"`
 	Label         LabelConfig     `env:",prefix=TANGLED_LABEL_"`
+	KnotMirror    string          `env:"TANGLED_KNOTMIRROR"`
 }
 
 func LoadConfig(ctx context.Context) (*Config, error) {

appview/pulls/pulls.go

···
 		return nil
 	}
 
-	scheme := "http"
-	if !s.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, repo.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-
-	resp, err := tangled.RepoBranch(r.Context(), xrpcc, branch, fmt.Sprintf("%s/%s", repo.Did, repo.Name))
+	xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror}
+	resp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, branch, repo.RepoAt().String())
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		return nil
 	}
···
 		return pages.Unknown
 	}
 
-	var knot, ownerDid, repoName string
-
+	var sourceRepo syntax.ATURI
 	if pull.PullSource.RepoAt != nil {
 		// fork-based pulls
-		sourceRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
-		if err != nil {
-			log.Println("failed to get source repo", err)
-			return pages.Unknown
-		}
-
-		knot = sourceRepo.Knot
-		ownerDid = sourceRepo.Did
-		repoName = sourceRepo.Name
+		sourceRepo = *pull.PullSource.RepoAt
 	} else {
 		// pulls within the same repo
-		knot = repo.Knot
-		ownerDid = repo.Did
-		repoName = repo.Name
+		sourceRepo = repo.RepoAt()
 	}
 
-	scheme := "http"
-	if !s.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-
-	didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName)
-	branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName)
+	xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror}
+	branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String())
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 			log.Println("failed to call XRPC repo.branches", xrpcerr)
···
 		return
 	}
 
-	scheme := "http"
-	if !s.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
+	xrpcc := &indigoxrpc.Client{Host: s.config.KnotMirror}
 
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
+	xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	if err != nil {
-		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.branches", xrpcerr)
-			s.pages.Error503(w)
-			return
-		}
 		log.Println("failed to fetch branches", err)
+		s.pages.Error503(w)
 		return
 	}
 

appview/repo/archive.go

···
 	"strings"
 
 	"github.com/go-chi/chi/v5"
+	"tangled.org/core/api/tangled"
 )
 
 func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {
···
 		l.Error("failed to get repo and knot", "err", err)
 		return
 	}
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	didSlashRepo := f.DidSlashRepo()
 
 	// build the xrpc url
-	u, err := url.Parse(host)
-	if err != nil {
-		l.Error("failed to parse host URL", "err", err)
-		rp.pages.Error503(w)
-		return
-	}
-
-	u.Path = "/xrpc/sh.tangled.repo.archive"
 	query := url.Values{}
+	query.Set("repo", f.RepoAt().String())
+	query.Set("ref", ref)
 	query.Set("format", "tar.gz")
 	query.Set("prefix", r.URL.Query().Get("prefix"))
-	query.Set("ref", ref)
-	query.Set("repo", didSlashRepo)
-	u.RawQuery = query.Encode()
-
-	xrpcURL := u.String()
+	xrpcURL := fmt.Sprintf(
+		"%s/xrpc/%s?%s",
+		rp.config.KnotMirror,
+		tangled.GitTempGetArchiveNSID,
+		query.Encode(),
+	)
 
 	// make the get request
 	resp, err := http.Get(xrpcURL)

appview/repo/artifact.go

···
 		return nil, err
 	}
 
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
 
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)
+	xrpcBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, f.RepoAt().String())
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 			l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

appview/repo/branches.go

···
 		l.Error("failed to get repo and knot", "err", err)
 		return
 	}
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
+
+	xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
+	if err != nil {
+		l.Error("failed to call XRPC repo.branches", "err", err)
 		rp.pages.Error503(w)
 		return
 	}

appview/repo/compare.go

···
 		return
 	}
 
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
 
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
+	branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
 		rp.pages.Error503(w)
···
 		head = queryHead
 	}
 
-	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
+	tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
 		rp.pages.Error503(w)

appview/repo/index.go

···
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/pages"
-	"tangled.org/core/appview/xrpcclient"
 	"tangled.org/core/orm"
 	"tangled.org/core/types"
 
···
 	if err != nil {
 		l.Error("failed to fully resolve repo", "err", err)
 		return
-	}
-
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
 	}
 
 	user := rp.oauth.GetMultiAccountUser(r)
 
 	// Build index response from multiple XRPC calls
-	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
-			l.Error("failed to call XRPC repo.index", "err", err)
-			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
-				LoggedInUser:     user,
-				NeedsKnotUpgrade: true,
-				RepoInfo:         rp.repoResolver.GetRepoInfo(r, user),
-			})
-			return
-		} else {
-			l.Error("failed to build index response", "err", err)
-			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
-				LoggedInUser:    user,
-				KnotUnreachable: true,
-				RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
-			})
-			return
-		}
+	result, err := rp.buildIndexResponse(r.Context(), f, ref)
+	if err != nil {
+		l.Error("failed to build index response", "err", err)
+		rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
+			LoggedInUser:    user,
+			KnotUnreachable: true,
+			RepoInfo:        rp.repoResolver.GetRepoInfo(r, user),
+		})
+		return
 	}
 
 	tagMap := make(map[string][]string)
···
 	}
 
 	// TODO: a bit dirty
-	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
+	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, result.Ref, ref == "")
 	if err != nil {
 		l.Warn("failed to compute language percentages", "err", err)
 		// non-fatal
···
 	ctx context.Context,
 	l *slog.Logger,
 	repo *models.Repo,
-	xrpcc *indigoxrpc.Client,
 	currentRef string,
 	isDefaultRef bool,
 ) ([]types.RepoLanguageDetails, error) {
···
 
 	if err != nil || langs == nil {
 		// non-fatal, fetch langs from ks via XRPC
-		didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
-		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo)
+		xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
+		ls, err := tangled.GitTempListLanguages(ctx, xrpcc, currentRef, repo.RepoAt().String())
 		if err != nil {
-			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-				l.Error("failed to call XRPC repo.languages", "err", xrpcerr)
-				return nil, xrpcerr
-			}
-			return nil, err
+			return nil, fmt.Errorf("calling knotmirror: %w", err)
 		}
 
 		if ls == nil || ls.Languages == nil {
···
 }
 
 // buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel
-func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
-	didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name)
+func (rp *Repo) buildIndexResponse(ctx context.Context, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) {
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
 
 	// first get branches to determine the ref if not specified
-	branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo)
+	branchesBytes, err := tangled.GitTempListBranches(ctx, xrpcc, "", 0, repo.RepoAt().String())
 	if err != nil {
-		return nil, fmt.Errorf("failed to call repoBranches: %w", err)
+		return nil, fmt.Errorf("calling knotmirror git.listBranches: %w", err)
 	}
 
 	var branchesResp types.RepoBranchesResponse
···
 
 	var (
 		tagsResp       types.RepoTagsResponse
-		treeResp       *tangled.RepoTree_Output
+		treeResp       *tangled.GitTempGetTree_Output
 		logResp        types.RepoLogResponse
 		readmeContent  string
 		readmeFileName string
···
 
 	// tags
 	wg.Go(func() {
-		tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo)
+		tagsBytes, err := tangled.GitTempListTags(ctx, xrpcc, "", 0, repo.RepoAt().String())
 		if err != nil {
-			errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err))
+			errs = errors.Join(errs, fmt.Errorf("failed to call git.ListTags: %w", err))
 			return
 		}
 
 		if err := json.Unmarshal(tagsBytes, &tagsResp); err != nil {
-			errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoTags: %w", err))
+			errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListTags: %w", err))
 		}
 	})
 
 	// tree/files
 	wg.Go(func() {
-		resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo)
+		resp, err := tangled.GitTempGetTree(ctx, xrpcc, "", ref, repo.RepoAt().String())
 		if err != nil {
-			errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err))
+			errs = errors.Join(errs, fmt.Errorf("failed to call git.GetTree: %w", err))
 			return
 		}
 		treeResp = resp
···
 
 	// commits
 	wg.Go(func() {
-		logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo)
+		logBytes, err := tangled.GitTempListCommits(ctx, xrpcc, "", 50, ref, repo.RepoAt().String())
 		if err != nil {
-			errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err))
+			errs = errors.Join(errs, fmt.Errorf("failed to call git.ListCommits: %w", err))
 			return
 		}
 
 		if err := json.Unmarshal(logBytes, &logResp); err != nil {
-			errs = errors.Join(errs, fmt.Errorf("failed to unmarshal repoLog: %w", err))
+			errs = errors.Join(errs, fmt.Errorf("failed to unmarshal git.ListCommits: %w", err))
 		}
 	})
 
···
 		Readme:         readmeContent,
 		ReadmeFileName: readmeFileName,
 		Commits:        logResp.Commits,
-		Description:    logResp.Description,
+		Description:    "",
 		Files:          files,
 		Branches:       branchesResp.Branches,
 		Tags:           tagsResp.Tags,

appview/repo/log.go

···
 	ref := chi.URLParam(r, "ref")
 	ref, _ = url.PathUnescape(ref)
 
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
 
 	limit := int64(60)
 	cursor := ""
···
 		cursor = strconv.Itoa(offset)
 	}
 
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		l.Error("failed to call XRPC repo.log", "err", xrpcerr)
+	xrpcBytes, err := tangled.GitTempListCommits(r.Context(), xrpcc, cursor, limit, ref, f.RepoAt().String())
+	if err != nil {
+		l.Error("failed to call XRPC repo.log", "err", err)
 		rp.pages.Error503(w)
 		return
 	}
···
 		return
 	}
 
-	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
+	tagBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
+	if err != nil {
+		l.Error("failed to call XRPC repo.tags", "err", err)
 		rp.pages.Error503(w)
 		return
 	}
···
 		}
 	}
 
-	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)
+	branchBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
+	if err != nil {
+		l.Error("failed to call XRPC repo.branches", "err", err)
 		rp.pages.Error503(w)
 		return
 	}

appview/repo/settings.go

···
 	f, err := rp.repoResolver.Resolve(r)
 	user := rp.oauth.GetMultiAccountUser(r)
 
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
 
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)
+	xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	var result types.RepoBranchesResponse
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

appview/repo/tags.go

···
 		l.Error("failed to get repo and knot", "err", err)
 		return
 	}
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)
-	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
+	xrpcBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 0, f.RepoAt().String())
+	if err != nil {
+		l.Error("failed to call XRPC repo.tags", "err", err)
 		rp.pages.Error503(w)
 		return
 	}
···
 		l.Error("failed to get repo and knot", "err", err)
 		return
 	}
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
 	tag := chi.URLParam(r, "tag")
 
-	xrpcBytes, err := tangled.RepoTag(r.Context(), xrpcc, repo, tag)
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
+
+	xrpcBytes, err := tangled.GitTempGetTag(r.Context(), xrpcc, f.RepoAt().String(), tag)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		// if we don't match an existing tag, and the tag we're trying
 		// to match is "latest", resolve to the most recent tag
 		if tag == "latest" {
-			tagsBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 1, repo)
+			tagsBytes, err := tangled.GitTempListTags(r.Context(), xrpcc, "", 1, f.RepoAt().String())
 			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 				l.Error("failed to call XRPC repo.tags for latest", "err", xrpcerr)
 				rp.pages.Error503(w)

appview/repo/tree.go

···
 	treePath := chi.URLParam(r, "*")
 	treePath, _ = url.PathUnescape(treePath)
 	treePath = strings.TrimSuffix(treePath, "/")
-	scheme := "http"
-	if !rp.config.Core.Dev {
-		scheme = "https"
-	}
-	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
-	xrpcc := &indigoxrpc.Client{
-		Host: host,
-	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
-	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)
+
+	xrpcc := &indigoxrpc.Client{Host: rp.config.KnotMirror}
+	xrpcResp, err := tangled.GitTempGetTree(r.Context(), xrpcc, treePath, ref, f.RepoAt().String())
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)
 		rp.pages.Error503(w)

knotmirror/config/config.go

···
 )
 
 type Config struct {
+	PlcUrl              string        `env:"MIRROR_PLC_URL, default=https://plc.directory"`
 	TapUrl              string        `env:"MIRROR_TAP_URL, default=http://localhost:2480"`
 	DbPath              string        `env:"MIRROR_DB_PATH, default=mirror.db"`
 	KnotUseSSL          bool          `env:"MIRROR_KNOT_USE_SSL, default=false"` // use SSL for Knot when not scheme is not specified
···
 	GitRepoFetchTimeout time.Duration `env:"MIRROR_GIT_FETCH_TIMEOUT, default=600s"`
 	ResyncParallelism   int           `env:"MIRROR_RESYNC_PARALLELISM, default=5"`
 	Slurper             SlurperConfig `env:",prefix=MIRROR_SLURPER_"`
+	UseSSL              bool          `env:"MIRROR_USE_SSL, default=false"`
+	Hostname            string        `env:"MIRROR_HOSTNAME, required"`
+	Listen              string        `env:"MIRROR_LISTEN, default=:7000"`
 	MetricsListen       string        `env:"MIRROR_METRICS_LISTEN, default=:7100"`
 	AdminListen         string        `env:"MIRROR_ADMIN_LISTEN, default=:7200"`
+}
+
+func (c *Config) BaseUrl() string {
+	if c.UseSSL {
+		return "https://" + c.Hostname
+	}
+	return "http://" + c.Hostname
 }
 
 type SlurperConfig struct {

knotmirror/knotmirror.go

···
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"tangled.org/core/idresolver"
 	"tangled.org/core/knotmirror/config"
 	"tangled.org/core/knotmirror/db"
 	"tangled.org/core/knotmirror/knotstream"
 	"tangled.org/core/knotmirror/models"
+	"tangled.org/core/knotmirror/xrpc"
 	"tangled.org/core/log"
 )
 
···
 	if err != nil {
 		return fmt.Errorf("initializing db: %w", err)
 	}
+
+	resolver := idresolver.DefaultResolver(cfg.PlcUrl)
 
 	res, err := db.ExecContext(ctx,
 		`update repos set state = $1 where state = $2`,
···
 	}
 	logger.Info(fmt.Sprintf("clearing resyning states: %d records updated", rows))
 
+	xrpc := xrpc.New(logger, cfg, db, resolver)
 	knotstream := knotstream.NewKnotStream(logger, db, cfg)
 	crawler := NewCrawler(logger, db)
 	resyncer := NewResyncer(logger, db, cfg)
···
 	// maintain repository list with tap
 	// NOTE: this can be removed once we introduce did-for-repo because then we can just listen to KnotStream for #identity events.
 	tap := NewTapClient(logger, cfg, db, knotstream)
+
+	// start xrpc server
+	go func() {
+		logger.Info("starting xrpc server", "addr", cfg.Listen)
+		if err := http.ListenAndServe(cfg.Listen, xrpc.Router()); err != nil {
+			logger.Error("xrpc server failed", "error", err)
+		}
+	}()
 
 	// start metrics endpoint
 	go func() {

knotmirror/xrpc/git_getArchive.go

···
+package xrpc
+
+import (
+	"compress/gzip"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/go-git/go-git/v5/plumbing"
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/knotmirror/db"
+	"tangled.org/core/knotserver/git"
+)
+
+func (x *Xrpc) GetArchive(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		ref       = r.URL.Query().Get("ref")
+		format    = r.URL.Query().Get("format")
+		prefix    = r.URL.Query().Get("prefix")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	if format != "tar.gz" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "only tar.gz format is supported"})
+		return
+	}
+	if format == "" {
+		format = "tar.gz"
+	}
+
+	l := x.logger.With("repo", repo, "ref", ref, "format", format, "prefix", prefix)
+	ctx := r.Context()
+
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		l.Error("failed to resolve repo at-uri", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to resolve repo"})
+		return
+	}
+
+	gr, err := git.Open(repoPath, ref)
+	if err != nil {
+		l.Error("failed to open git repo", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to open git repo"})
+		return
+	}
+
+	repoName, err := func() (string, error) {
+		r, err := db.GetRepoByAtUri(ctx, x.db, repo)
+		if err != nil {
+			return "", err
+		}
+		return r.Name, nil
+	}()
+	if err != nil {
+		l.Error("failed to get repo name", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to retrieve repo name"})
+		return
+	}
+
+	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")
+	immutableLink := func() string {
+		params := url.Values{}
+		params.Set("repo", repo.String())
+		params.Set("ref", gr.Hash().String())
+		params.Set("format", format)
+		params.Set("prefix", prefix)
+		return fmt.Sprintf("%s/xrpc/%s?%s", x.cfg.BaseUrl(), tangled.GitTempGetArchiveNSID, params.Encode())
+	}()
+
+	filename := fmt.Sprintf("%s-%s.tar.gz", repoName, safeRefFilename)
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
+	w.Header().Set("Content-Type", "application/gzip")
+	w.Header().Set("Link", fmt.Sprintf("<%s>; rel=\"immutable\"", immutableLink))
+
+	gw := gzip.NewWriter(w)
+	defer gw.Close()
+
+	if err := gr.WriteTar(gw, prefix); err != nil {
+		// once we start writing to the body we can't report error anymore
+		// so we are only left with logging the error
+		l.Error("writing tar file", "err", err.Error())
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	if err := gw.Flush(); err != nil {
+		// once we start writing to the body we can't report error anymore
+		// so we are only left with logging the error
+		l.Error("flushing", "err", err.Error())
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+}

knotmirror/xrpc/git_getBlob.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"slices"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"tangled.org/core/knotserver/git"
+)
+
+func (x *Xrpc) GetBlob(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		ref       = r.URL.Query().Get("ref") // ref can be empty (git.Open handles this)
+		path      = r.URL.Query().Get("path")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	l := x.logger.With("repo", repo, "ref", ref, "path", path)
+
+	if path == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "missing path parameter"})
+		return
+	}
+
+	file, err := x.getFile(r.Context(), repo, ref, path)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to get blob", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to get blob"})
+		return
+	}
+
+	reader, err := file.Reader()
+	if err != nil {
+		l.Error("failed to read blob", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to read the blob"})
+	}
+	defer reader.Close()
+
+	w.Header().Set("Content-Type", "application/octet-stream")
+	if _, err := io.Copy(w, reader); err != nil {
+		l.Error("failed to serve the blob", "err", err)
+	}
+}
+
+func (x *Xrpc) getFile(ctx context.Context, repo syntax.ATURI, ref, path string) (*object.File, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("resolving repo at-uri: %w", err)
+	}
+
+	gr, err := git.Open(repoPath, ref)
+	if err != nil {
+		return nil, fmt.Errorf("opening git repo: %w", err)
+	}
+
+	return gr.File(path)
+}
+
+var textualMimeTypes = []string{
+	"application/json",
+	"application/xml",
+	"application/yaml",
+	"application/x-yaml",
+	"application/toml",
+	"application/javascript",
+	"application/ecmascript",
+}
+
+// isTextualMimeType returns true if the MIME type represents textual content
+// that should be served as text/plain for security reasons
+func isTextualMimeType(mimeType string) bool {
+	return slices.Contains(textualMimeTypes, mimeType)
+}

knotmirror/xrpc/git_getBranch.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/knotserver/git"
+)
+
+// TODO: maybe rename to `sh.tangled.repo.temp.getCommit`?
+func (x *Xrpc) GetBranch(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		nameQuery = r.URL.Query().Get("name")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	if nameQuery == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "missing name parameter"})
+		return
+	}
+	branchName, _ := url.PathUnescape(nameQuery)
+
+	l := x.logger.With("repo", repo, "branch", branchName)
+
+	out, err := x.getBranch(r.Context(), repo, branchName)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to get branch", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to get branch"})
+		return
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) getBranch(ctx context.Context, repo syntax.ATURI, branchName string) (*tangled.GitTempGetBranch_Output, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
+	}
+
+	gr, err := git.PlainOpen(repoPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open git repo: %w", err)
+	}
+
+	ref, err := gr.Branch(branchName)
+	if err != nil {
+		return nil, fmt.Errorf("getting branch '%s': %w", branchName, err)
+	}
+
+	commit, err := gr.Commit(ref.Hash())
+	if err != nil {
+		return nil, fmt.Errorf("getting commit '%s': %w", ref.Hash(), err)
+	}
+
+	out := tangled.GitTempGetBranch_Output{
+		Name: ref.Name().Short(),
+		Hash: ref.Hash().String(),
+		When: commit.Author.When.Format(time.RFC3339),
+		Author: &tangled.GitTempDefs_Signature{
+			Name:  commit.Author.Name,
+			Email: commit.Author.Email,
+			When:  commit.Author.When.Format(time.RFC3339),
+		},
+	}
+
+	if commit.Message != "" {
+		out.Message = &commit.Message
+	}
+
+	return &out, nil
+}

knotmirror/xrpc/git_getTag.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"tangled.org/core/knotserver/git"
+	"tangled.org/core/types"
+)
+
+func (x *Xrpc) GetTag(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		tagName   = r.URL.Query().Get("tag")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	if tagName == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: "missing 'tag' parameter"})
+		return
+	}
+
+	l := x.logger.With("repo", repo, "tag", tagName)
+
+	out, err := x.getTag(r.Context(), repo, tagName)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to get tag", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to get tag"})
+		return
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) getTag(ctx context.Context, repo syntax.ATURI, tagName string) (*types.RepoTagResponse, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
+	}
+
+	gr, err := git.PlainOpen(repoPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open git repo: %w", err)
+	}
+
+	// if this is not already formatted as refs/tags/v0.1.0, then format it
+	if !plumbing.ReferenceName(tagName).IsTag() {
+		tagName = plumbing.NewTagReferenceName(tagName).String()
+	}
+
+	tag, err := func() (object.Tag, error) {
+		tags, err := gr.Tags(&git.TagsOptions{
+			Pattern: tagName,
+		})
+		if err != nil {
+			return object.Tag{}, err
+		}
+		if len(tags) != 1 {
+			return object.Tag{}, fmt.Errorf("expected 1 tag to be returned, got %d tags", len(tags))
+		}
+		return tags[0], nil
+	}()
+	if err != nil {
+		return nil, fmt.Errorf("getting tag: %w", err)
+	}
+
+	var target *object.Tag
+	if tag.Target != plumbing.ZeroHash {
+		target = &tag
+	}
+
+	return &types.RepoTagResponse{
+		Tag: &types.TagReference{
+			Tag: target,
+			Reference: types.Reference{
+				Name: tag.Name,
+				Hash: tag.Hash.String(),
+			},
+			Message: tag.Message,
+		},
+	}, nil
+}

knotmirror/xrpc/git_getTree.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"time"
+	"unicode/utf8"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/pages/markup"
+	"tangled.org/core/knotserver/git"
+)
+
+func (x *Xrpc) GetTree(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		ref       = r.URL.Query().Get("ref")  // ref can be empty (git.Open handles this)
+		path      = r.URL.Query().Get("path") // path can be empty (defaults to root)
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	l := x.logger.With("repo", repo, "ref", ref, "path", path)
+
+	out, err := x.getTree(r.Context(), repo, ref, path)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to get tree", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to get tree"})
+		return
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) getTree(ctx context.Context, repo syntax.ATURI, ref, path string) (*tangled.GitTempGetTree_Output, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
+	}
+
+	gr, err := git.Open(repoPath, ref)
+	if err != nil {
+		return nil, fmt.Errorf("opening git repo: %w", err)
+	}
+
+	files, err := gr.FileTree(ctx, path)
+	if err != nil {
+		return nil, fmt.Errorf("reading file tree: %w", err)
+	}
+
+	// if any of these files are a readme candidate, pass along its blob contents too
+	var readmeFileName string
+	var readmeContents string
+	for _, file := range files {
+		if markup.IsReadmeFile(file.Name) {
+			contents, err := gr.RawContent(filepath.Join(path, file.Name))
+			if err != nil {
+				x.logger.Error("failed to read contents of file", "path", path, "file", file.Name)
+			}
+
+			if utf8.Valid(contents) {
+				readmeFileName = file.Name
+				readmeContents = string(contents)
+				break
+			}
+		}
+	}
+
+	// convert NiceTree -> tangled.RepoTempGetTree_TreeEntry
+	treeEntries := make([]*tangled.GitTempGetTree_TreeEntry, len(files))
+	for i, file := range files {
+		entry := &tangled.GitTempGetTree_TreeEntry{
+			Name: file.Name,
+			Mode: file.Mode,
+			Size: file.Size,
+		}
+		if file.LastCommit != nil {
+			entry.Last_commit = &tangled.GitTempGetTree_LastCommit{
+				Hash:    file.LastCommit.Hash.String(),
+				Message: file.LastCommit.Message,
+				When:    file.LastCommit.When.Format(time.RFC3339),
+			}
+		}
+		treeEntries[i] = entry
+	}
+
+	var parentPtr *string
+	if path != "" {
+		parentPtr = &path
+	}
+
+	var dotdotPtr *string
+	if path != "" {
+		dotdot := filepath.Dir(path)
+		if dotdot != "." {
+			dotdotPtr = &dotdot
+		}
+	}
+
+	return &tangled.GitTempGetTree_Output{
+		Ref:    ref,
+		Parent: parentPtr,
+		Dotdot: dotdotPtr,
+		Files:  treeEntries,
+		Readme: &tangled.GitTempGetTree_Readme{
+			Filename: readmeFileName,
+			Contents: readmeContents,
+		},
+	}, nil
+}

knotmirror/xrpc/git_listBranches.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"path/filepath"
+	"strconv"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/knotserver/git"
+	"tangled.org/core/types"
+)
+
+func (x *Xrpc) ListBranches(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery   = r.URL.Query().Get("repo")
+		limitQuery  = r.URL.Query().Get("limit")
+		cursorQuery = r.URL.Query().Get("cursor")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	limit := 50
+	if limitQuery != "" {
+		limit, err = strconv.Atoi(limitQuery)
+		if err != nil || limit < 1 || limit > 1000 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("limit parameter invalid: %s", limitQuery)})
+			return
+		}
+	}
+
+	var cursor int64
+	if cursorQuery != "" {
+		cursor, err = strconv.ParseInt(cursorQuery, 10, 64)
+		if err != nil || cursor < 0 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("cursor parameter invalid: %s", cursorQuery)})
+			return
+		}
+	}
+
+	l := x.logger.With("repo", repoQuery, "limit", limit, "cursor", cursor)
+
+	out, err := x.listBranches(r.Context(), repo, limit, cursor)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to list branches", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to list branches"})
+		return
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) listBranches(ctx context.Context, repo syntax.ATURI, limit int, cursor int64) (*types.RepoBranchesResponse, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("resolving repo at-uri: %w", err)
+	}
+
+	gr, err := git.PlainOpen(repoPath)
+	if err != nil {
+		return nil, fmt.Errorf("opening git repo: %w", err)
+	}
+
+	branches, err := gr.Branches(&git.BranchesOptions{
+		Limit:  limit,
+		Offset: int(cursor),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("listing git branches: %w", err)
+	}
+
+	return &types.RepoBranchesResponse{
+		// TODO: include default branch and cursor
+		Branches: branches,
+	}, nil
+}
+
+func (x *Xrpc) makeRepoPath(ctx context.Context, repo syntax.ATURI) (string, error) {
+	id, err := x.resolver.ResolveIdent(ctx, repo.Authority().String())
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(
+		x.cfg.GitRepoBasePath,
+		id.DID.String(),
+		repo.RecordKey().String(),
+	), nil
+}

knotmirror/xrpc/git_listCommits.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/knotserver/git"
+	"tangled.org/core/types"
+)
+
+func (x *Xrpc) ListCommits(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery   = r.URL.Query().Get("repo")
+		ref         = r.URL.Query().Get("ref") // ref can be empty (git.Open handles this)
+		limitQuery  = r.URL.Query().Get("limit")
+		cursorQuery = r.URL.Query().Get("cursor")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	limit := 50
+	if limitQuery != "" {
+		limit, err = strconv.Atoi(limitQuery)
+		if err != nil || limit < 1 || limit > 1000 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("limit parameter invalid: %s", limitQuery)})
+			return
+		}
+	}
+
+	var cursor int64
+	if cursorQuery != "" {
+		cursor, err = strconv.ParseInt(cursorQuery, 10, 64)
+		if err != nil || cursor < 0 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("cursor parameter invalid: %s", cursorQuery)})
+			return
+		}
+	}
+
+	l := x.logger.With("repo", repo, "ref", ref)
+
+	out, err := x.listCommits(r.Context(), repo, ref, limit, cursor)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to list commits", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to list commits"})
+		return
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) listCommits(ctx context.Context, repo syntax.ATURI, ref string, limit int, cursor int64) (*types.RepoLogResponse, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("resolving repo at-uri: %w", err)
+	}
+
+	gr, err := git.Open(repoPath, ref)
+	if err != nil {
+		return nil, fmt.Errorf("opening git repo: %w", err)
+	}
+
+	offset := int(cursor)
+
+	commits, err := gr.Commits(offset, limit)
+	if err != nil {
+		return nil, fmt.Errorf("listing git commits: %w", err)
+	}
+
+	tcommits := make([]types.Commit, len(commits))
+	for i, c := range commits {
+		tcommits[i].FromGoGitCommit(c)
+	}
+
+	total, err := gr.TotalCommits()
+	if err != nil {
+		return nil, fmt.Errorf("counting total commits: %w", err)
+	}
+
+	return &types.RepoLogResponse{
+		Commits: tcommits,
+		Ref: ref,
+		Page:    (offset / limit) + 1,
+		PerPage: limit,
+		Total:   total,
+		Log:     true,
+	}, nil
+}

knotmirror/xrpc/git_listLanguages.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"net/http"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/knotserver/git"
+)
+
+func (x *Xrpc) ListLanguages(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery = r.URL.Query().Get("repo")
+		ref       = r.URL.Query().Get("ref")
+	)
+	l := x.logger.With("repo", repoQuery, "ref", ref)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		l.Error("invalid repo at-uri", "err", err)
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+		return
+	}
+
+	out, err := x.listLanguages(r.Context(), repo, ref)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to list languages", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to list languages"})
+		return
+	}
+
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) listLanguages(ctx context.Context, repo syntax.ATURI, ref string) (*tangled.GitTempListLanguages_Output, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("resolving repo at-uri: %w", err)
+	}
+
+	gr, err := git.Open(repoPath, ref)
+	if err != nil {
+		return nil, fmt.Errorf("opening git repo: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
+	defer cancel()
+
+	sizes, err := gr.AnalyzeLanguages(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("analyzing languages: %w", err)
+	}
+
+	return &tangled.GitTempListLanguages_Output{
+		Ref: ref,
+		Languages: sizesToLanguages(sizes),
+	}, nil
+}
+
+func sizesToLanguages(sizes git.LangBreakdown) []*tangled.GitTempListLanguages_Language {
+	var apiLanguages []*tangled.GitTempListLanguages_Language
+	var totalSize int64
+	for _, size := range sizes {
+		totalSize += size
+	}
+
+	for name, size := range sizes {
+		percentagef64 := float64(size) / float64(totalSize) * 100
+		percentage := math.Round(percentagef64)
+
+		lang := &tangled.GitTempListLanguages_Language{
+			Name:       name,
+			Size:       size,
+			Percentage: int64(percentage),
+		}
+
+		apiLanguages = append(apiLanguages, lang)
+	}
+
+	return apiLanguages
+}

knotmirror/xrpc/git_listTags.go

···
+package xrpc
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/go-git/go-git/v5/plumbing"
+	"github.com/go-git/go-git/v5/plumbing/object"
+	"tangled.org/core/knotserver/git"
+	"tangled.org/core/types"
+)
+
+func (x *Xrpc) ListTags(w http.ResponseWriter, r *http.Request) {
+	var (
+		repoQuery   = r.URL.Query().Get("repo")
+		limitQuery  = r.URL.Query().Get("limit")
+		cursorQuery = r.URL.Query().Get("cursor")
+	)
+
+	repo, err := syntax.ParseATURI(repoQuery)
+	if err != nil || repo.RecordKey() == "" {
+		writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("repo parameter invalid: %s", repoQuery)})
+	}
+
+	limit := 50
+	if limitQuery != "" {
+		limit, err = strconv.Atoi(limitQuery)
+		if err != nil || limit < 1 || limit > 1000 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("limit parameter invalid: %s", limitQuery)})
+		}
+	}
+
+	var cursor int64
+	if cursorQuery != "" {
+		cursor, err = strconv.ParseInt(cursorQuery, 10, 64)
+		if err != nil || cursor < 0 {
+			writeJson(w, http.StatusBadRequest, atclient.ErrorBody{Name: "BadRequest", Message: fmt.Sprintf("cursor parameter invalid: %s", cursorQuery)})
+		}
+	}
+
+	l := x.logger.With("repo", repo, "limit", limit, "cursor", cursor)
+
+	out, err := x.listTags(r.Context(), repo, limit, cursor)
+	if err != nil {
+		// TODO: better error return
+		l.Error("failed to list tags", "err", err)
+		writeJson(w, http.StatusInternalServerError, atclient.ErrorBody{Name: "InternalServerError", Message: "failed to list tags"})
+	}
+	writeJson(w, http.StatusOK, out)
+}
+
+func (x *Xrpc) listTags(ctx context.Context, repo syntax.ATURI, limit int, cursor int64) (*types.RepoTagsResponse, error) {
+	repoPath, err := x.makeRepoPath(ctx, repo)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve repo at-uri: %w", err)
+	}
+
+	gr, err := git.PlainOpen(repoPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open git repo: %w", err)
+	}
+
+	tags, err := gr.Tags(&git.TagsOptions{
+		Limit:  limit,
+		Offset: int(cursor),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to get git tags: %w", err)
+	}
+
+	rtags := make([]*types.TagReference, len(tags))
+	for i, tag := range tags {
+		var target *object.Tag
+		if tag.Target != plumbing.ZeroHash {
+			target = &tag
+		}
+		rtags[i] = &types.TagReference{
+			Reference: types.Reference{
+				Name: tag.Name,
+				Hash: tag.Hash.String(),
+			},
+			Tag:     target,
+			Message: tag.Message,
+		}
+	}
+
+	return &types.RepoTagsResponse{
+		Tags: rtags,
+	}, nil
+}

knotmirror/xrpc/xrpc.go

···
+package xrpc
+
+import (
+	"database/sql"
+	"encoding/json"
+	"log/slog"
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"tangled.org/core/api/tangled"
+	"tangled.org/core/idresolver"
+	"tangled.org/core/knotmirror/config"
+)
+
+type Xrpc struct {
+	cfg      *config.Config
+	db       *sql.DB
+	resolver *idresolver.Resolver
+	logger   *slog.Logger
+}
+
+func New(logger *slog.Logger, cfg *config.Config, db *sql.DB, resolver *idresolver.Resolver) *Xrpc {
+	return &Xrpc{
+		cfg,
+		db,
+		resolver,
+		logger,
+	}
+}
+
+func (x *Xrpc) Router() http.Handler {
+	r := chi.NewRouter()
+
+	r.Route("/xrpc", func(r chi.Router) {
+		r.Get("/"+tangled.GitTempGetArchiveNSID, x.GetArchive)
+		r.Get("/"+tangled.GitTempGetBlobNSID, x.GetBlob)
+		r.Get("/"+tangled.GitTempGetBranchNSID, x.GetBranch)
+		// r.Get("/"+tangled.GitTempGetCommitNSID, x.GetCommit) // todo
+		// r.Get("/"+tangled.GitTempGetDiffNSID, x.GetDiff) // todo
+		// r.Get("/"+tangled.GitTempGetEntityNSID, x.GetEntity) // todo
+		// r.Get("/"+tangled.GitTempGetHeadNSID, x.GetHead) // todo
+		r.Get("/"+tangled.GitTempGetTagNSID, x.GetTag) // using types.Response
+		r.Get("/"+tangled.GitTempGetTreeNSID, x.GetTree)
+		r.Get("/"+tangled.GitTempListBranchesNSID, x.ListBranches) // wip, unknown output
+		r.Get("/"+tangled.GitTempListCommitsNSID, x.ListCommits)
+		r.Get("/"+tangled.GitTempListLanguagesNSID, x.ListLanguages)
+		r.Get("/"+tangled.GitTempListTagsNSID, x.ListTags)
+	})
+
+	return r
+}
+
+func writeJson(w http.ResponseWriter, status int, response any) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		return err
+	}
+	return nil
+}

knotserver/git/git.go

···
 	return io.ReadAll(reader)
 }
 
+func (g *GitRepo) File(path string) (*object.File, error) {
+	c, err := g.r.CommitObject(g.h)
+	if err != nil {
+		return nil, fmt.Errorf("commit object: %w", err)
+	}
+
+	tree, err := c.Tree()
+	if err != nil {
+		return nil, fmt.Errorf("file tree: %w", err)
+	}
+
+	return tree.File(path)
+}
+
 // read and parse .gitmodules
 func (g *GitRepo) Submodules() (*config.Modules, error) {
 	c, err := g.r.CommitObject(g.h)