set default branch from KNOT_REPO_MAIN_BRANCH

knotserver/config/config.go

···
 type Repo struct {
 	ScanPath   string   `env:"SCAN_PATH, default=/home/git"`
 	Readme     []string `env:"README"`
-	MainBranch []string `env:"MAIN_BRANCH"`
+	MainBranch string   `env:"MAIN_BRANCH, default=main"`
 }
 
 type Server struct {

knotserver/git/git.go

···
 	return branches, nil
 }
 
-func (g *GitRepo) FindMainBranch(branches []string) (string, error) {
-	branches = append(branches, []string{
-		"main",
-		"master",
-		"trunk",
-	}...)
-	for _, b := range branches {
-		_, err := g.r.ResolveRevision(plumbing.Revision(b))
-		if err == nil {
-			return b, nil
-		}
+func (g *GitRepo) FindMainBranch() (string, error) {
+	ref, err := g.r.Head()
+	if err != nil {
+		return "", fmt.Errorf("unable to find main branch: %w", err)
 	}
-	return "", fmt.Errorf("unable to find main branch")
+	return string(ref.Name()), err
 }
 
 // WriteTar writes itself from a tree into a binary tar file format.

knotserver/git/repo.go

···
 
 	gogit "github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/config"
+	"github.com/go-git/go-git/v5/plumbing"
 )
 
-func InitBare(path string) error {
+func InitBare(path, defaultBranch string) error {
 	parent := filepath.Dir(path)
 
 	if err := os.MkdirAll(parent, 0755); errors.Is(err, os.ErrExist) {
···
 		return err
 	}
 
+	// set up default branch
 	err = repository.CreateBranch(&config.Branch{
-		Name: "main",
+		Name: defaultBranch,
 	})
 	if err != nil {
 		return fmt.Errorf("creating branch: %w", err)
+	}
+
+	defaultReference := plumbing.ReferenceName(fmt.Sprintf("refs/heads/%s", defaultBranch))
+
+	ref := plumbing.NewSymbolicReference(plumbing.HEAD, defaultReference)
+	if err = repository.Storer.SetReference(ref); err != nil {
+		return fmt.Errorf("creating symbolic reference: %w", err)
 	}
 
 	return nil

knotserver/routes.go

···
 	"errors"
 	"fmt"
 	"html/template"
+	"log"
 	"net/http"
 	"path/filepath"
 	"strconv"
···
 
 	gr, err := git.Open(path, ref)
 	if err != nil {
+		log.Println(err)
 		if errors.Is(err, plumbing.ErrReferenceNotFound) {
 			resp := types.RepoIndexResponse{
 				IsEmpty: true,
···
 	}
 
 	if ref == "" {
-		mainBranch, err := gr.FindMainBranch(h.c.Repo.MainBranch)
+		mainBranch, err := gr.FindMainBranch()
 		if err != nil {
 			writeError(w, err.Error(), http.StatusInternalServerError)
 			l.Error("finding main branch", "error", err.Error())
···
 	l := h.l.With("handler", "NewRepo")
 
 	data := struct {
-		Did  string `json:"did"`
-		Name string `json:"name"`
+		Did           string `json:"did"`
+		Name          string `json:"name"`
+		DefaultBranch string `json:"default_branch,omitempty"`
 	}{}
 
 	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
···
 		return
 	}
 
+	if data.DefaultBranch == "" {
+		data.DefaultBranch = "main"
+	}
+
 	did := data.Did
 	name := data.Name
+	defaultBranch := data.DefaultBranch
 
 	relativeRepoPath := filepath.Join(did, name)
 	repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath)
-	err := git.InitBare(repoPath)
+	err := git.InitBare(repoPath, defaultBranch)
 	if err != nil {
 		l.Error("initializing bare repo", "error", err.Error())
 		if errors.Is(err, gogit.ErrRepositoryAlreadyExists) {