Commit `34a78ef570`

34a78ef570fbffbfc01e61a70c85f049c100fc5f

parent: 5671f4a322

Verified · cmc

cmc <hello@cleberg.net> · 2026-09-05 05:28 UTC

wiki: pages move into .gitbay/wiki on the default branch

The companion bare repo (<owner>/<name>.wiki.git) is gone: its SSH
route, the wikiDir helpers that resolved it, the reserved .wiki name
suffix, and its rename/delete handling. Pages now live at
.gitbay/wiki/*.{md,org,markdown} on the repository's default branch,
resolved and access-checked through the parent exactly as before.
wiki list and wiki show keep their argv, JSON fields and exit codes,
except that a repository with no .gitbay/wiki now reports an empty
list instead of erroring, since that is the common case for every
repository until the one production wiki is migrated by hand.

Writing is unchanged in kind: a push, or repo commit-file, like any
other file. No wiki-specific write command is added.

InitBare's empty-hooksPath branch was reachable only from the removed
companion init call; removed along with the comment describing it.

Closes #170

Layout: unified · split

cmd/gitbayd/backup.go +1 −1

		@@ -267,7 +267,7 @@ func verifyBackup(path string) error {
267	267	return fmt.Errorf("%s: %d repositories the database names are not in the archive: %s", path, len(missing), strings.Join(missing, ", "))
268	268	}
269	269	if extra > 0 {
270		fmt.Printf("%d repositories in the archive that the database does not name (deleted after the snapshot, or a wiki)\n", extra)
	270	fmt.Printf("%d repositories in the archive that the database does not name (deleted after the snapshot)\n", extra)
271	271	}
272	272	return nil
273	273	}

e2e/readonly_test.go +1 −1

		@@ -152,7 +152,7 @@ func TestReadOnlyCommandsWriteNothing(t *testing.T) {
152	152	"wiki show": {"alice/app"},
153	153	}
154	154	// Reads whose subject legitimately does not exist in this fixture.
155		notFoundOK := map[string]bool{"wiki list": true, "wiki show": true, "repo deps status": true}
	155	notFoundOK := map[string]bool{"wiki show": true, "repo deps status": true}
156	156
157	157	dbPath := filepath.Join(inst.root, "gitbay.db")
158	158	before := dbFingerprint(t, dbPath)

e2e/wiki_test.go +55 −28

		@@ -11,7 +11,8 @@ func TestWikis(t *testing.T) {
11	11	inst := startInstance(t)
12	12	aliceKey := inst.newKey(t, "alice")
13	13	bobKey := inst.newKey(t, "bob")
14		inst.admin(t, "admin", "user", "create", "alice", "--key", aliceKey+".pub")
	14	inst.admin(t, "admin", "user", "create", "alice",
	15	"--key", aliceKey+".pub", "--email", "alice@example.test", "--verified")
15	16	inst.admin(t, "admin", "user", "create", "bob", "--key", bobKey+".pub")
16	17	if _, _, code := inst.ssh(t, aliceKey, "", "repo", "create", "alice/app"); code != 0 {
17	18	t.Fatal("repo create failed")
		@@ -20,8 +21,8 @@ func TestWikis(t *testing.T) {
20	21	t.Fatal("private repo create failed")
21	22	}
22	23
23		// No wiki yet: the tab is absent, the page shows the push hint, and
24		// cloning the companion says so.
	24	// No wiki yet: the tab is absent, the page shows the missing hint, and
	25	// listing reports no wiki rather than erroring.
25	26	_, body := inst.get(t, "/alice/app")
26	27	if strings.Contains(body, ">Wiki<") {
27	28	t.Fatal("wiki tab shown with no wiki")
		@@ -30,26 +31,29 @@ func TestWikis(t *testing.T) {
30	31	if !strings.Contains(body, "no wiki yet") {
31	32	t.Fatal("missing-wiki hint absent")
32	33	}
33		env := inst.gitEnv(aliceKey)
34		if out, code := gitRun(t, t.TempDir(), env, "clone", inst.sshURL("alice/app.wiki"), "w"); code == 0 \|\| !strings.Contains(out, "no wiki yet") {
35		t.Fatalf("clone of absent wiki: %d\n%s", code, out)
	34	if out, errOut, code := inst.ssh(t, aliceKey, "", "wiki", "list", "alice/app", "--json"); code != 0 {
	35	t.Fatalf("wiki list on a repo without one: %s", errOut)
	36	} else if !strings.Contains(out, `"pages":[]`) {
	37	t.Errorf("wiki list on a repo without one returned pages: %s", out)
36	38	}
37	39
38		// First push creates the wiki. A reader without write cannot push it.
	40	// Pages are ordinary files: pushing them creates the wiki.
	41	env := inst.gitEnv(aliceKey)
39	42	work := t.TempDir()
40	43	mustGit(t, work, env, "init", "-q", "-b", "main", "w")
41	44	dir := filepath.Join(work, "w")
42		os.WriteFile(filepath.Join(dir, "Home.md"), []byte(
	45	os.MkdirAll(filepath.Join(dir, ".gitbay", "wiki"), 0o755)
	46	os.WriteFile(filepath.Join(dir, ".gitbay", "wiki", "Home.md"), []byte(
43	47	"# welcome\n\nsee [Setup](Setup.md) and ![shot](shot.png)\n"), 0o644)
44		os.WriteFile(filepath.Join(dir, "Setup.org"), []byte("* setup\n\nsteps here\n"), 0o644)
45		os.WriteFile(filepath.Join(dir, "shot.png"), []byte{0x89, 0x50, 0x4e, 0x47}, 0o644)
	48	os.WriteFile(filepath.Join(dir, ".gitbay", "wiki", "Setup.org"), []byte("* setup\n\nsteps here\n"), 0o644)
	49	os.WriteFile(filepath.Join(dir, ".gitbay", "wiki", "shot.png"), []byte{0x89, 0x50, 0x4e, 0x47}, 0o644)
46	50	mustGit(t, dir, env, "add", ".")
47	51	mustGit(t, dir, env, "commit", "-q", "-m", "wiki start")
48		mustGit(t, dir, env, "push", "-q", inst.sshURL("alice/app.wiki"), "main")
	52	mustGit(t, dir, env, "push", "-q", inst.sshURL("alice/app"), "main")
49	53
50	54	benv := inst.gitEnv(bobKey)
51		if out, code := gitRun(t, dir, benv, "push", inst.sshURL("alice/app.wiki"), "main"); code == 0 && !strings.Contains(out, "denied") {
52		t.Fatalf("reader pushed the wiki: %d\n%s", code, out)
	55	if out, code := gitRun(t, dir, benv, "push", inst.sshURL("alice/app"), "main"); code == 0 && !strings.Contains(out, "denied") {
	56	t.Fatalf("reader pushed the repository: %d\n%s", code, out)
53	57	}
54	58
55	59	// Rendering: home resolves, tab appears, links rewrite to wiki pages
		@@ -115,10 +119,12 @@ func TestWikis(t *testing.T) {
115	119	if _, _, code := inst.ssh(t, aliceKey, "", "wiki", "show", "alice/app", "../../etc/passwd"); code == 0 {
116	120	t.Error("wiki show escaped the repository")
117	121	}
118		// A repository with no wiki says so rather than failing oddly.
119		if _, errOut, code := inst.ssh(t, aliceKey, "", "wiki", "list", "alice/secretive"); code == 0 \|\|
120		!strings.Contains(errOut, "no wiki") {
121		t.Errorf("wiki list on a repo without one: %d %s", code, errOut)
	122	// A repository with no wiki says so rather than failing oddly, even
	123	// for its owner.
	124	if out, errOut, code := inst.ssh(t, aliceKey, "", "wiki", "list", "alice/secretive", "--json"); code != 0 {
	125	t.Fatalf("wiki list on a repo without one: %s", errOut)
	126	} else if !strings.Contains(out, `"pages":[]`) {
	127	t.Errorf("wiki list on a repo without one returned pages: %s", out)
122	128	}
123	129	// Wiki access derives from the parent: a stranger gets nothing.
124	130	if _, _, code := inst.ssh(t, bobKey, "", "wiki", "list", "alice/secretive"); code == 0 {
		@@ -126,24 +132,45 @@ func TestWikis(t *testing.T) {
126	132	}
127	133
128	134	// 404-parity: a private repo's wiki is invisible, over web and git.
129		mustGit(t, dir, env, "push", "-q", inst.sshURL("alice/secretive.wiki"), "main")
130	135	if status, _ := inst.get(t, "/alice/secretive/wiki"); status != 404 {
131	136	t.Fatalf("private wiki page: %d", status)
132	137	}
133		if out, code := gitRun(t, t.TempDir(), benv, "clone", inst.sshURL("alice/secretive.wiki"), "x"); code == 0 \|\| !strings.Contains(out, "not found") {
134		t.Fatalf("private wiki clone by outsider: %d\n%s", code, out)
	138
	139	// Pushing to <name>.wiki.git is refused now that the companion route
	140	// is gone; there is no such repository.
	141	if out, code := gitRun(t, t.TempDir(), env, "clone", inst.sshURL("alice/app.wiki"), "x"); code == 0 {
	142	t.Fatalf("cloned a nonexistent companion: %s", out)
	143	} else if !strings.Contains(out, "not found") {
	144	t.Fatalf("clone of alice/app.wiki: %s", out)
135	145	}
136	146
137		// Repo names ending .wiki are refused (companion namespace).
138		if _, errOut, code := inst.ssh(t, aliceKey, "", "repo", "create", "alice/notes.wiki"); code != 2 \|\| !strings.Contains(errOut, "reserved") {
139		t.Fatalf(".wiki name allowed: %d %s", code, errOut)
	147	// A repository may now be named something.wiki: the suffix is no
	148	// longer reserved.
	149	if _, errOut, code := inst.ssh(t, aliceKey, "", "repo", "create", "alice/notes.wiki"); code != 0 {
	150	t.Fatalf("something.wiki repo name refused: %s", errOut)
140	151	}
141	152
142		// Deleting the repo removes the wiki companion.
143		if _, _, code := inst.ssh(t, aliceKey, "", "repo", "delete", "alice/secretive", "--yes"); code != 0 {
144		t.Fatal("repo delete failed")
	153	// repo commit-file writes a page on a repository that permits
	154	// server-authored commits: it is the command behind the web editor,
	155	// and there is no wiki-specific write command.
	156	if _, errOut, code := inst.ssh(t, aliceKey, "written by commit-file\n",
	157	"repo", "commit-file", "alice/app", ".gitbay/wiki/Extra.md",
	158	"--ref", "main", "--message", "'add a page'", "--file", "-"); code != 0 {
	159	t.Fatalf("repo commit-file: %s", errOut)
	160	}
	161	out, _, code = inst.ssh(t, aliceKey, "", "wiki", "show", "alice/app", "Extra", "--json")
	162	if code != 0 \|\| !strings.Contains(out, "written by commit-file") {
	163	t.Errorf("wiki show Extra: %s", out)
145	164	}
146		if _, err := os.Stat(filepath.Join(inst.root, "repos", "alice", "secretive.wiki.git")); err == nil {
147		t.Fatal("wiki survived repo delete")
	165
	166	// A repository requiring verified signatures refuses repo commit-file,
	167	// since the server cannot sign on the user's behalf.
	168	if _, _, code := inst.ssh(t, aliceKey, "", "repo", "settings", "require-signed", "alice/app", "on"); code != 0 {
	169	t.Fatal("require-signed failed")
	170	}
	171	if _, errOut, code := inst.ssh(t, aliceKey, "blocked\n",
	172	"repo", "commit-file", "alice/app", ".gitbay/wiki/Blocked.md",
	173	"--ref", "main", "--file", "-"); code == 0 \|\| !strings.Contains(errOut, "requires signed commits") {
	174	t.Errorf("repo commit-file not refused on a signed-commits repo: %d %s", code, errOut)
148	175	}
149	176	}

internal/control/repo.go +1 −7

		@@ -392,11 +392,6 @@ func runRepoTransfer(c *Ctx, args []string) int {
392	392	}
393	393	return c.fail(protocol.ExitFailure, "moving repository: %v", err)
394	394	}
395		// The wiki companion follows its repo.
396		oldWiki := RepoDir(c.Cfg.Server.Root, repo.OwnerName, repo.Name+".wiki")
397		if _, err := os.Stat(oldWiki); err == nil {
398		os.Rename(oldWiki, RepoDir(c.Cfg.Server.Root, newOwner, repo.Name+".wiki"))
399		}
400	395	newPath := newOwner + "/" + repo.Name
401	396	return c.emit(map[string]string{"repo": newPath, "was": repo.Path()}, func(w io.Writer) {
402	397	fmt.Fprintf(w, "transferred %s to %s — clone URLs now use %s\n", repo.Path(), newPath, newPath)
		@@ -429,7 +424,7 @@ func runRepoDelete(c *Ctx, args []string) int {
429	424	}
430	425
431	426	// deleteRepo removes a repository the caller has already been cleared to
432		// delete: the database row, then the directory and its wiki companion.
	427	// delete: the database row, then the directory.
433	428	//
434	429	// There is deliberately no repo.deleted event. events.repo_id and
435	430	// webhooks.repo_id both cascade from repos, so recording one would delete
		@@ -449,7 +444,6 @@ func deleteRepo(c *Ctx, repo store.Repo) int {
449	444	if err := os.RemoveAll(RepoDir(c.Cfg.Server.Root, repo.OwnerName, repo.Name)); err != nil {
450	445	return c.fail(protocol.ExitFailure, "database row removed but disk cleanup failed: %v", err)
451	446	}
452		os.RemoveAll(RepoDir(c.Cfg.Server.Root, repo.OwnerName, repo.Name+".wiki"))
453	447	return c.emit(map[string]string{"deleted": repo.Path()}, func(w io.Writer) {
454	448	fmt.Fprintf(w, "deleted %s\n", repo.Path())
455	449	})

internal/control/wiki.go +24 −28

		@@ -4,7 +4,6 @@ import (
4	4	"encoding/base64"
5	5	"fmt"
6	6	"io"
7		"os"
8	7	"path"
9	8	"strings"
10	9
		@@ -31,39 +30,36 @@ func init() {
31	30	})
32	31	}
33	32
34		// A wiki lives in a companion bare repo beside its parent, so prose
35		// edits stay out of the code repository's history, its protected
36		// branches and its builds. The companion has no store row of its own —
37		// access derives from the parent, exactly as it does for git over SSH —
38		// which is why it needs commands rather than being addressable as a
39		// repository.
	33	// Wiki pages are files under .gitbay/wiki on the repository's default
	34	// branch, alongside ci.yml and CODEOWNERS. They have no store row of
	35	// their own — access derives from the parent, exactly as it does for any
	36	// other path in the repository.
40	37	//
41		// Editing stays a push to <repo>.wiki.git. That is the whole write
42		// interface, on every surface, and there is nothing for a command to
43		// add.
	38	// Writing is a push, or repo commit-file, like any other file in the
	39	// repository. There is no wiki-specific write command.
44	40
45	41	// wikiExts are the page formats the web renders, in resolution order.
46	42	var wikiExts = []string{".md", ".org", ".markdown"}
47	43
48		// wikiDir resolves the parent, checks read access, and returns the
49		// companion's path. A parent you cannot read has no wiki you can read.
50		func wikiDir(c *Ctx, spec string) (repo store.Repo, dir string, code int) {
	44	// wikiTreePath is where wiki pages live in a repository's tree.
	45	const wikiTreePath = ".gitbay/wiki"
	46
	47	// wikiDir resolves the parent, checks read access, and returns its
	48	// directory and default branch. A parent you cannot read has no wiki you
	49	// can read.
	50	func wikiDir(c *Ctx, spec string) (repo store.Repo, dir, branch string, code int) {
51	51	parent, code := resolveRepo(c, spec, policy.CanRead)
52	52	if code >= 0 {
53		return store.Repo{}, "", code
54		}
55		d := RepoDir(c.Cfg.Server.Root, parent.OwnerName, parent.Name+".wiki")
56		if _, err := os.Stat(d); err != nil {
57		return store.Repo{}, "", c.fail(protocol.ExitNotFound, "%s has no wiki", parent.Path())
	53	return store.Repo{}, "", "", code
58	54	}
59		return parent, d, -1
	55	return parent, RepoDir(c.Cfg.Server.Root, parent.OwnerName, parent.Name), parent.DefaultBranch, -1
60	56	}
61	57
62		// wikiPages lists the page names in the companion, without extensions.
63		func wikiPages(dir string) []string {
64		entries, err := gitutil.ListTree(dir, "main", "")
	58	// wikiPages lists the page names under .gitbay/wiki, without extensions.
	59	func wikiPages(dir, branch string) []string {
	60	entries, err := gitutil.ListTree(dir, branch, wikiTreePath)
65	61	if err != nil {
66		return nil // the companion exists but has no commits yet
	62	return nil // no .gitbay/wiki tree on this branch
67	63	}
68	64	var pages []string
69	65	for _, e := range entries {
		@@ -85,11 +81,11 @@ func runWikiList(c *Ctx, args []string) int {
85	81	if len(args) != 1 {
86	82	return c.fail(protocol.ExitUsage, "usage: wiki list <owner/name>")
87	83	}
88		repo, dir, code := wikiDir(c, args[0])
	84	repo, dir, branch, code := wikiDir(c, args[0])
89	85	if code >= 0 {
90	86	return code
91	87	}
92		pages := wikiPages(dir)
	88	pages := wikiPages(dir, branch)
93	89	type out struct {
94	90	Path string `json:"path"`
95	91	Home string `json:"home,omitempty"`
		@@ -126,11 +122,11 @@ func runWikiShow(c *Ctx, args []string) int {
126	122	if len(args) < 1 \|\| len(args) > 2 {
127	123	return c.fail(protocol.ExitUsage, "usage: wiki show <owner/name> [<page>]")
128	124	}
129		repo, dir, code := wikiDir(c, args[0])
	125	repo, dir, branch, code := wikiDir(c, args[0])
130	126	if code >= 0 {
131	127	return code
132	128	}
133		pages := wikiPages(dir)
	129	pages := wikiPages(dir, branch)
134	130	page := wikiHome(pages)
135	131	if len(args) == 2 {
136	132	page = strings.TrimSuffix(args[1], path.Ext(args[1]))
		@@ -144,7 +140,7 @@ func runWikiShow(c *Ctx, args []string) int {
144	140	}
145	141
146	142	for _, ext := range wikiExts {
147		raw, err := gitutil.ReadBlob(dir, "main", page+ext, c.Cfg.Limits.MaxBlobBytes)
	143	raw, err := gitutil.ReadBlob(dir, branch, wikiTreePath+"/"+page+ext, c.Cfg.Limits.MaxBlobBytes)
148	144	if err != nil {
149	145	continue
150	146	}

internal/gitutil/gitutil.go +3 −7

		@@ -25,13 +25,9 @@ func InitBare(path, defaultBranch, hooksPath string) error {
25	25	if out, err := cmd.CombinedOutput(); err != nil {
26	26	return fmt.Errorf("git init: %v\n%s", err, out)
27	27	}
28		// An empty hooksPath leaves the bare repo with no hooks — used for
29		// companion repos (wikis) that carry no ref policy.
30		if hooksPath != "" {
31		cmd = exec.Command(toolpath.Look("git"), "-C", path, "config", "core.hooksPath", hooksPath)
32		if out, err := cmd.CombinedOutput(); err != nil {
33		return fmt.Errorf("git config core.hooksPath: %v\n%s", err, out)
34		}
	28	cmd = exec.Command(toolpath.Look("git"), "-C", path, "config", "core.hooksPath", hooksPath)
	29	if out, err := cmd.CombinedOutput(); err != nil {
	30	return fmt.Errorf("git config core.hooksPath: %v\n%s", err, out)
35	31	}
36	32	return nil
37	33	}

internal/httpd/web.go +1 −1

		@@ -333,7 +333,7 @@ func (s Server) repoFor(w http.ResponseWriter, r http.Request, ref string) (re
333	333	Mirrors: mirrors,
334	334	Pinned: pinned,
335	335	Watch: watch,
336		HasWiki: s.wikiDir(repo.OwnerName, repo.Name) != "",
	336	HasWiki: s.hasWiki(repo),
337	337	Host: s.cfg.SiteHost(),
338	338	Desc: gitutil.ReadDescription(control.RepoDir(s.cfg.Server.Root, repo.OwnerName, repo.Name)),
339	339	Repo: repo,

internal/httpd/wiki.go +18 −26

		@@ -3,7 +3,6 @@ package httpd
3	3	import (
4	4	"html/template"
5	5	"net/http"
6		"os"
7	6	"path"
8	7	"strings"
9	8
		@@ -15,16 +14,24 @@ import (
15	14	"gitbay.org/gitbay/internal/store"
16	15	)
17	16
18		// wikiDir returns the companion repo path, or "" when the repo has none.
19		func (s *Server) wikiDir(owner, name string) string {
20		dir := control.RepoDir(s.cfg.Server.Root, owner, name+".wiki")
21		if _, err := os.Stat(dir); err != nil {
22		return ""
23		}
24		return dir
	17	// wikiTreePath is where wiki pages live in a repository's tree.
	18	const wikiTreePath = ".gitbay/wiki"
	19
	20	// wikiDir returns repo's directory and default branch, where wiki pages
	21	// are resolved from .gitbay/wiki.
	22	func (s *Server) wikiDir(repo store.Repo) (dir, branch string) {
	23	return control.RepoDir(s.cfg.Server.Root, repo.OwnerName, repo.Name), repo.DefaultBranch
	24	}
	25
	26	// hasWiki reports whether repo's default branch holds a non-empty
	27	// .gitbay/wiki tree.
	28	func (s *Server) hasWiki(repo store.Repo) bool {
	29	dir, branch := s.wikiDir(repo)
	30	entries, err := gitutil.ListTree(dir, branch, wikiTreePath)
	31	return err == nil && len(entries) > 0
25	32	}
26	33
27		// wiki renders a page from the repo's wiki companion. The home page is
	34	// wiki renders a page from the repo's .gitbay/wiki tree. The home page is
28	35	// Home.<ext> (or README.<ext>); /wiki/<name> resolves <name> with .md and
29	36	// .org fallbacks. Rendering reuses the same sanitized pipeline as READMEs.
30	37	func (s Server) wiki(w http.ResponseWriter, r http.Request) {
		@@ -33,17 +40,6 @@ func (s Server) wiki(w http.ResponseWriter, r http.Request) {
33	40	return
34	41	}
35	42	p.Tab = "wiki"
36		dir := s.wikiDir(p.Repo.OwnerName, p.Repo.Name)
37		if dir == "" {
38		s.render(w, "wiki.html", struct {
39		repoPage
40		Page string
41		PageHTML template.HTML
42		Pages []string
43		Missing bool
44		}{repoPage: p, Missing: true})
45		return
46		}
47	43	var listing struct {
48	44	Home string `json:"home"`
49	45	Pages []string `json:"pages"`
		@@ -97,12 +93,8 @@ func (s Server) wikiRaw(w http.ResponseWriter, r http.Request) {
97	93	if !ok {
98	94	return
99	95	}
100		dir := s.wikiDir(p.Repo.OwnerName, p.Repo.Name)
101		if dir == "" {
102		s.notFound(w, r)
103		return
104		}
105		data, err := gitutil.ReadBlob(dir, "main", strings.Trim(r.PathValue("path"), "/"), s.cfg.Limits.MaxBlobBytes)
	96	dir, branch := s.wikiDir(p.Repo)
	97	data, err := gitutil.ReadBlob(dir, branch, path.Join(wikiTreePath, strings.Trim(r.PathValue("path"), "/")), s.cfg.Limits.MaxBlobBytes)
106	98	if err != nil {
107	99	s.notFound(w, r)
108	100	return

internal/policy/names.go −3

		@@ -59,9 +59,6 @@ func ValidateName(name string) error {
59	59	if len(name) > 4 && name[len(name)-4:] == ".git" {
60	60	return fmt.Errorf("invalid name %q: must not end in .git", name)
61	61	}
62		if len(name) > 5 && name[len(name)-5:] == ".wiki" {
63		return fmt.Errorf("invalid name %q: .wiki names are reserved for wiki companion repositories", name)
64		}
65	62	return nil
66	63	}
67	64

internal/sshd/sshd.go −60

		@@ -16,7 +16,6 @@ import (
16	16	"os"
17	17	"path/filepath"
18	18	"strconv"
19		"strings"
20	19	"sync"
21	20	"sync/atomic"
22	21	"time"
		@@ -356,12 +355,6 @@ func runGit(cfg config.Config, st *store.Store, user store.User, scope string, a
356	355	}
357	356	write := service == "git-receive-pack"
358	357
359		// Wiki companion repos: ssh://.../owner/name.wiki.git. Access derives
360		// from the parent repo; the bare repo is created on first push.
361		if base, ok := strings.CutSuffix(strings.TrimSuffix(argv[1], ".git"), ".wiki"); ok {
362		return runWikiGit(cfg, st, user, scope, service, base, write, stdin, stdout, stderr)
363		}
364
365	358	repo, err := st.RepoByPath(argv[1])
366	359	if err != nil {
367	360	fmt.Fprintln(stderr, "repository not found")
		@@ -433,56 +426,3 @@ func runGit(cfg config.Config, st *store.Store, user store.User, scope string, a
433	426	}
434	427	return protocol.ExitOK
435	428	}
436
437		// runWikiGit serves a repo's wiki companion. The wiki carries no ref
438		// policy (no hooks, no merge requests); access is exactly the parent
439		// repo's, and the bare repo is created on the first push. Deploy keys —
440		// bound to the repo's own git data for CI — cannot touch the wiki.
441		func runWikiGit(cfg config.Config, st *store.Store, user store.User, scope, service, basePath string,
442		write bool, stdin io.Reader, stdout, stderr io.Writer) int {
443		repo, err := st.RepoByPath(basePath)
444		if err != nil {
445		fmt.Fprintln(stderr, "repository not found")
446		return protocol.ExitNotFound
447		}
448		if policy.IsDeployScope(scope) {
449		fmt.Fprintln(stderr, "repository not found")
450		return protocol.ExitNotFound
451		}
452		grant, err := st.AccessRole(repo.ID, user.ID)
453		if err != nil {
454		fmt.Fprintln(stderr, "internal error")
455		return protocol.ExitFailure
456		}
457		if !policy.CanRead(user, repo, grant) {
458		fmt.Fprintln(stderr, "repository not found")
459		return protocol.ExitNotFound
460		}
461		if !policy.ScopeAllowsGit(scope, repo.Path(), write) {
462		fmt.Fprintf(stderr, "this key's scope (%s) does not allow %s on the wiki\n", scope, service)
463		return protocol.ExitDenied
464		}
465		if write && !policy.CanWrite(user, repo, grant) {
466		fmt.Fprintf(stderr, "write access to %s wiki denied\n", repo.Path())
467		return protocol.ExitDenied
468		}
469		if write && repo.Settings.Archived {
470		fmt.Fprintf(stderr, "%s is archived and read-only\n", repo.Path())
471		return protocol.ExitDenied
472		}
473		dir := control.RepoDir(cfg.Server.Root, repo.OwnerName, repo.Name+".wiki")
474		if _, err := os.Stat(dir); err != nil {
475		if !write {
476		fmt.Fprintln(stderr, "this repository has no wiki yet")
477		return protocol.ExitNotFound
478		}
479		if err := gitutil.InitBare(dir, "main", ""); err != nil {
480		fmt.Fprintln(stderr, "initializing wiki failed")
481		return protocol.ExitFailure
482		}
483		}
484		if err := gitutil.Transport(service, dir, stdin, stdout, stderr, nil, cfg.Limits.MaxPackBytes); err != nil {
485		return protocol.ExitFailure
486		}
487		return protocol.ExitOK
488		}

internal/web/templates/wiki.html +3 −3

		@@ -1,8 +1,8 @@
1	1	{{define "title"}}wiki{{if .Page}}: {{.Page}}{{end}} · {{.Repo.OwnerName}}/{{.Repo.Name}}{{end}}
2	2	{{define "content"}}
3	3	<h1 class="vh">Wiki{{if .Page}}: {{.Page}}{{end}}</h1>
4		{{if .Missing}}<p class="empty-note">no wiki yet — create one by pushing pages:<br>
5		<code>git clone ssh://git@{{.Host}}/{{.Repo.OwnerName}}/{{.Repo.Name}}.wiki.git</code> then add <code>Home.md</code> (or .org) and push.</p>
	4	{{if .Missing}}<p class="empty-note">no wiki yet — add pages under <code>.gitbay/wiki/</code> on the default branch:<br>
	5	push <code>.gitbay/wiki/Home.md</code> (or .org), or use the file editor.</p>
6	6	{{else}}
7	7	<div class="wikilayout">
8	8	<div class="wikipage">
		@@ -14,7 +14,7 @@
14	14	<nav class="wikinav">
15	15	<p class="meta">pages</p>
16	16	<ul>{{range .Pages}}<li><a {{if eq . $.Page}}class="active" {{end}}href="/{{$.Repo.OwnerName}}/{{$.Repo.Name}}/wiki/{{.}}">{{.}}</a></li>{{end}}</ul>
17		<p class="meta">edit by push:<br><code>{{.Repo.Path}}.wiki.git</code></p>
	17	<p class="meta">edit under <code>.gitbay/wiki/</code> — push, or the file editor.</p>
18	18	</nav>
19	19	</div>
20	20	{{end}}

Commit 34a78ef570

Commit `34a78ef570`