Commit `7f6601266e`

7f6601266e978b4782642424c80db6c01f06c96f

parent: 5e5b5210b9

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-02 04:36 UTC

control: admin commands as screens

admin user list (pending accounts lead with ●) and show, admin repo
list, admin runners, admin stats (the 20 largest repositories, then
admin repo list), admin mr prune, and admin mail inbound check. The
enabled inbound check needs a live mailbox and is covered by build and
vet only.

Ref #319

Layout: unified · split

internal/control/admin.go +142 −5

	@@ -159,7 +159,7 @@ func runAdminUserList(c *Ctx, args []string) int {
159	for _, u := range users {	159	for _, u := range users {
160	ds = append(ds, adminUserRow(u))	160	ds = append(ds, adminUserRow(u))
161	}	161	}
162	return c.emitPage(p, ds, next, func(w io.Writer) {	162	return c.emitPageView(p, ds, next, func(w io.Writer) {
163	tb := c.table(w, "USERNAME", "STATE", "ADMIN", "CREATED", "LAST SEEN")	163	tb := c.table(w, "USERNAME", "STATE", "ADMIN", "CREATED", "LAST SEEN")
164	for _, d := range ds {	164	for _, d := range ds {
165	mark := ""	165	mark := ""
	@@ -169,6 +169,25 @@ func runAdminUserList(c *Ctx, args []string) int {
169	tb.row(cRef(d.Username), cState(d.State), cText(mark), cAge(d.CreatedAt), cAge(d.LastSeen))	169	tb.row(cRef(d.Username), cState(d.State), cText(mark), cAge(d.CreatedAt), cAge(d.LastSeen))
170	}	170	}
171	tb.flush()	171	tb.flush()
		172	}, func() screen {
		173	rows := make([]row, len(ds))
		174	for i, d := range ds {
		175	lead := cGlyph("")
		176	if d.State == "pending" {
		177	lead = cYou()
		178	}
		179	admin, seen := "", ""
		180	if d.Admin {
		181	admin = "admin"
		182	}
		183	if d.LastSeen != "" {
		184	seen = "seen " + relAge(d.LastSeen, termNow())
		185	}
		186	rows[i] = rowOf(cRef(d.Username), lead, cState(d.State), cMeta(admin, seen))
		187	}
		188	return listScreen("Accounts", rows,
		189	action{"Filter", []string{"admin", "user", "list", "--state", "pending"}},
		190	)
172	})	191	})
173	}	192	}
174		193
	@@ -280,7 +299,7 @@ func runAdminUserShow(c *Ctx, args []string) int {
280	return c.fail(protocol.ExitFailure, "%v", err)	299	return c.fail(protocol.ExitFailure, "%v", err)
281	}	300	}
282		301
283	return c.emit(d, func(w io.Writer) {	302	return c.emitView(d, func(w io.Writer) {
284	admin := ""	303	admin := ""
285	if d.Admin {	304	if d.Admin {
286	admin = "yes"	305	admin = "yes"
	@@ -346,6 +365,66 @@ func runAdminUserShow(c *Ctx, args []string) int {
346	}	365	}
347	tt.flush()	366	tt.flush()
348	}	367	}
		368	}, func() screen {
		369	s := screen{}
		370	user := []cell{cRef(d.Username), cState(d.State)}
		371	if d.Admin {
		372	user = append(user, cMeta("admin"))
		373	}
		374	seen := "never seen"
		375	if d.LastSeen != "" {
		376	seen = "seen " + relAge(d.LastSeen, termNow())
		377	}
		378	s.fields = []field{
		379	{"User", user},
		380	{"Seen", []cell{cText(seen), cMeta("created " + relAge(d.CreatedAt, termNow()))}},
		381	{"Repos", []cell{cText(strconv.FormatInt(d.Repos, 10))}},
		382	{"Sessions", []cell{cText(strconv.FormatInt(d.WebSessions, 10))}},
		383	}
		384	keys := section{title: "Keys", n: len(d.Keys)}
		385	for _, k := range d.Keys {
		386	keys.rows = append(keys.rows, rowOf(cRef(k.Fingerprint), cState(k.Scope), cMeta(k.Algo, "used "+relAge(k.LastUsedAt, termNow()))))
		387	}
		388	emails := section{title: "Emails", n: len(d.Emails)}
		389	for _, e := range d.Emails {
		390	state, primary := "unverified", ""
		391	if e.Verified {
		392	state = "verified"
		393	}
		394	if e.Primary {
		395	primary = "primary"
		396	}
		397	emails.rows = append(emails.rows, rowOf(cRef(e.Address), cState(state), cMeta(primary, e.VerifiedBy)))
		398	}
		399	pgp := section{title: "PGP keys", n: len(d.PGPKeys)}
		400	for _, k := range d.PGPKeys {
		401	pgp.rows = append(pgp.rows, rowOf(cRef(k.Fingerprint)))
		402	}
		403	orgs := section{title: "Orgs", n: len(d.Orgs)}
		404	for _, o := range d.Orgs {
		405	orgs.rows = append(orgs.rows, rowOf(cLink(o.Org, c.siteURL(o.Org)), cState(o.Role)))
		406	}
		407	tokens := section{title: "API tokens", n: len(d.APITokens)}
		408	for _, tk := range d.APITokens {
		409	used := ""
		410	if tk.LastUsedAt != nil {
		411	used = "used " + relAge(tk.LastUsedAt.UTC().Format(time.RFC3339Nano), termNow())
		412	}
		413	tokens.rows = append(tokens.rows, rowOf(cRef(tk.Name), cState(tk.Scope), cMeta(used)))
		414	}
		415	s.sections = []section{keys, emails, pgp, orgs, tokens}
		416	role, state := "promote", "disable"
		417	if d.Admin {
		418	role = "demote"
		419	}
		420	if d.State == "disabled" {
		421	state = "enable"
		422	}
		423	s.actions = []action{
		424	{"Manage", []string{"admin", "user", role, d.Username}},
		425	{"Manage", []string{"admin", "user", state, d.Username}},
		426	}
		427	return s
349	})	428	})
350	}	429	}
351		430
	@@ -439,7 +518,7 @@ func runAdminRepoList(c *Ctx, args []string) int {
439	size := gitutil.DirSize(RepoDir(c.Cfg.Server.Root, r.OwnerName, r.Name))	518	size := gitutil.DirSize(RepoDir(c.Cfg.Server.Root, r.OwnerName, r.Name))
440	ds = append(ds, out{r.Path, r.Visibility, r.Archived, r.CreatedAt, r.LastPush, size})	519	ds = append(ds, out{r.Path, r.Visibility, r.Archived, r.CreatedAt, r.LastPush, size})
441	}	520	}
442	return c.emitPage(p, ds, next, func(w io.Writer) {	521	return c.emitPageView(p, ds, next, func(w io.Writer) {
443	tb := c.table(w, "PATH", "VISIBILITY", "BYTES", "CREATED", "LAST PUSH")	522	tb := c.table(w, "PATH", "VISIBILITY", "BYTES", "CREATED", "LAST PUSH")
444	for _, d := range ds {	523	for _, d := range ds {
445	cells := []cell{cLink(d.Path, c.siteURL(d.Path)), cState(d.Visibility), cSize(d.Bytes), cAge(d.CreatedAt), cAge(d.LastPush)}	524	cells := []cell{cLink(d.Path, c.siteURL(d.Path)), cState(d.Visibility), cSize(d.Bytes), cAge(d.CreatedAt), cAge(d.LastPush)}
	@@ -449,6 +528,22 @@ func runAdminRepoList(c *Ctx, args []string) int {
449	tb.row(cells...)	528	tb.row(cells...)
450	}	529	}
451	tb.flush()	530	tb.flush()
		531	}, func() screen {
		532	rows := make([]row, len(ds))
		533	for i, d := range ds {
		534	state := d.Visibility
		535	if d.Archived {
		536	state += ", archived"
		537	}
		538	pushed := ""
		539	if d.LastPush != "" {
		540	pushed = "pushed " + relAge(d.LastPush, termNow())
		541	}
		542	rows[i] = rowOf(cLink(d.Path, c.siteURL(d.Path)), cState(state), cSize(d.Bytes), cMeta(pushed))
		543	}
		544	return listScreen("Repositories", rows,
		545	action{"Filter", []string{"admin", "repo", "list", "--visibility", "private"}},
		546	)
452	})	547	})
453	}	548	}
454		549
	@@ -574,7 +669,7 @@ func runAdminRunners(c *Ctx, args []string) int {
574	}	669	}
575	}	670	}
576	d := map[string]any{"queue": queue, "runners": runners}	671	d := map[string]any{"queue": queue, "runners": runners}
577	return c.emit(d, func(w io.Writer) {	672	return c.emitView(d, func(w io.Writer) {
578	v := c.view(w)	673	v := c.view(w)
579	v.fields(	674	v.fields(
580	"pending", fmt.Sprintf("%d", queue.Pending),	675	"pending", fmt.Sprintf("%d", queue.Pending),
	@@ -599,6 +694,32 @@ func runAdminRunners(c *Ctx, args []string) int {
599	tb.row(cText(r.Username), cText(r.Fingerprint), cAge(r.LastSeen), cFlex(scope), cText(held))	694	tb.row(cText(r.Username), cText(r.Fingerprint), cAge(r.LastSeen), cFlex(scope), cText(held))
600	}	695	}
601	tb.flush()	696	tb.flush()
		697	}, func() screen {
		698	s := screen{fields: []field{{"Queue", []cell{
		699	cText(fmt.Sprintf("%d pending", queue.Pending)),
		700	cMeta(fmt.Sprintf("%d claimed in 24h", queue.Claimed24h), "wait avg "+c.Term.dur(queue.ClaimWaitAvgS),
		701	"max "+c.Term.dur(queue.ClaimWaitMaxS), fmt.Sprintf("%d reaped", queue.Reaped24h)),
		702	}}}}
		703	runnersSec := section{title: "Runners", n: len(runners)}
		704	idle := ""
		705	for _, r := range runners {
		706	scope := r.Scope
		707	if scope == "" {
		708	scope = "any"
		709	}
		710	lead, held := cGlyph(""), "idle"
		711	if r.BuildNumber != 0 {
		712	lead, held = cGlyph("running"), fmt.Sprintf("building %s #%d %s", r.BuildRepo, r.BuildNumber, r.BuildJob)
		713	} else if idle == "" {
		714	idle = r.Fingerprint
		715	}
		716	runnersSec.rows = append(runnersSec.rows, rowOf(cRef(r.Username), lead, cFlex(scope), cMeta("seen "+relAge(r.LastSeen, termNow()), held)))
		717	}
		718	s.sections = []section{runnersSec}
		719	if idle != "" {
		720	s.actions = []action{{"Prune", []string{"admin", "runners", "remove", idle}}}
		721	}
		722	return s
602	})	723	})
603	}	724	}
604		725
	@@ -687,7 +808,7 @@ func runAdminMRPrune(c *Ctx, args []string) int {
687	if err := gitutil.PruneNow(dir); err != nil {	808	if err := gitutil.PruneNow(dir); err != nil {
688	return c.fail(protocol.ExitFailure, "%v; the head refs are deleted but the objects are not yet pruned; re-run the same command", err)	809	return c.fail(protocol.ExitFailure, "%v; the head refs are deleted but the objects are not yet pruned; re-run the same command", err)
689	}	810	}
690	return c.emit(rows, func(w io.Writer) {	811	return c.emitView(rows, func(w io.Writer) {
691	tb := c.table(w, "!", "HEAD")	812	tb := c.table(w, "!", "HEAD")
692	for _, r := range rows {	813	for _, r := range rows {
693	if r.Head == "" {	814	if r.Head == "" {
	@@ -697,5 +818,21 @@ func runAdminMRPrune(c *Ctx, args []string) int {
697	tb.row(cRef(fmt.Sprintf("!%d", r.Number)), cRef(r.Head))	818	tb.row(cRef(fmt.Sprintf("!%d", r.Number)), cRef(r.Head))
698	}	819	}
699	tb.flush()	820	tb.flush()
		821	}, func() screen {
		822	rs := make([]row, len(rows))
		823	for i, r := range rows {
		824	n := strconv.FormatInt(r.Number, 10)
		825	ref := cLink("!"+n, c.siteURL(repo.Path(), "mrs", n))
		826	if r.Head == "" {
		827	rs[i] = rowOf(ref, cGlyph("skipped"), cMeta("already gone"))
		828	continue
		829	}
		830	rs[i] = rowOf(ref, cGlyph("ok"), cRef(fmt.Sprintf("%.10s", r.Head)))
		831	}
		832	s := listScreen("Pruned", rs)
		833	if len(rows) > 0 {
		834	s.actions = []action{{"Read", []string{"mr", "show", repo.Path(), strconv.FormatInt(rows[0].Number, 10)}}}
		835	}
		836	return s
700	})	837	})
701	}	838	}

internal/control/adminhost.go +27 −1

	@@ -1,10 +1,12 @@
1	package control	1	package control
2		2
3	import (	3	import (
		4	"cmp"
4	"errors"	5	"errors"
5	"fmt"	6	"fmt"
6	"io"	7	"io"
7	"os"	8	"os"
		9	"slices"
8		10
9	"golang.org/x/crypto/ssh"	11	"golang.org/x/crypto/ssh"
10		12
	@@ -324,7 +326,7 @@ func runAdminStats(c *Ctx, args []string) int {
324	if fi, err := os.Stat(c.Cfg.Server.Root + "/gitbay.db"); err == nil {	326	if fi, err := os.Stat(c.Cfg.Server.Root + "/gitbay.db"); err == nil {
325	d.DBBytes = fi.Size()	327	d.DBBytes = fi.Size()
326	}	328	}
327	return c.emit(d, func(w io.Writer) {	329	return c.emitView(d, func(w io.Writer) {
328	v := c.view(w)	330	v := c.view(w)
329	v.fields(	331	v.fields(
330	"users", fmt.Sprintf("%d", counts.Users),	332	"users", fmt.Sprintf("%d", counts.Users),
	@@ -344,6 +346,30 @@ func runAdminStats(c *Ctx, args []string) int {
344	}	346	}
345	tb.flush()	347	tb.flush()
346	}	348	}
		349	}, func() screen {
		350	count := func(all, open int64) []cell {
		351	return []cell{cText(fmt.Sprint(all)), cMeta(fmt.Sprintf("%d open", open))}
		352	}
		353	s := screen{fields: []field{
		354	{"Users", []cell{cText(fmt.Sprint(counts.Users))}},
		355	{"Orgs", []cell{cText(fmt.Sprint(counts.Orgs))}},
		356	{"Repos", []cell{cText(fmt.Sprint(counts.Repos))}},
		357	{"Issues", count(counts.Issues, counts.OpenIssues)},
		358	{"MRs", count(counts.MRs, counts.OpenMRs)},
		359	{"Disk", []cell{cSize(d.DBBytes), cMeta("database", "repositories "+humanBytes(d.RepoBytes), "lfs "+humanBytes(d.LFSBytes))}},
		360	}}
		361	repos := slices.Clone(d.Repos)
		362	slices.SortStableFunc(repos, func(a, b repoDisk) int { return cmp.Compare(b.Bytes, a.Bytes) })
		363	top := section{title: "Repositories", n: len(repos), more: []string{"admin", "repo", "list"}}
		364	for _, r := range repos[:min(20, len(repos))] {
		365	top.rows = append(top.rows, rowOf(cLink(r.Path, c.siteURL(r.Path)), cSize(r.Bytes)))
		366	}
		367	s.sections = []section{top}
		368	s.actions = []action{
		369	{"Admin", []string{"admin", "user", "list"}},
		370	{"Admin", []string{"admin", "runners"}},
		371	}
		372	return s
347	})	373	})
348	}	374	}
349		375

internal/control/adminmail.go +20 −2

 		Warning           string `json:"warning,omitempty"`
 	}
 	if !in.Enabled {
-		return c.emit(out{}, func(w io.Writer) {
+		return c.emitView(out{}, func(w io.Writer) {
 			fmt.Fprintln(w, "inbound mail is off ([mail.inbound] enabled = false)")
+		}, func() screen {
+			return screen{fields: []field{{"Inbound", []cell{cText("off")}}}}
 		})
 	}
 	cl, n, err := imapc.Open(in, true, 30*time.Second)
 		d.Warning = unauthenticatedWarning
 		fmt.Fprintln(c.Stderr, "warning: "+d.Warning)
 	}
-	return c.emit(d, func(w io.Writer) {
+	return c.emitView(d, func(w io.Writer) {
 		c.view(w).fields(
 			"server", d.Server,
 			"mailbox", d.Mailbox,
 			"require_dkim", fmt.Sprintf("%t", d.RequireDKIM),
 			"trusted_authserv_id", d.TrustedAuthservID,
 		)
+	}, func() screen {
+		auth := cMark("✓ dkim", sgrGreen)
+		if d.Warning != "" {
+			auth = cMark("✗ "+d.Warning, sgrRed)
+		} else if !d.RequireDKIM {
+			auth = cMeta("dkim not required")
+		}
+		s := screen{fields: []field{
+			{"Inbound", []cell{cText(d.Server), cMeta(d.Mailbox)}},
+			{"Messages", []cell{cText(fmt.Sprint(d.Messages)), cMeta(fmt.Sprintf("%d unseen", d.Unseen))}},
+			{"Auth", []cell{auth}},
+		}}
+		if d.TrustedAuthservID != "" {
+			s.fields = append(s.fields, field{"Authserv", []cell{cText(d.TrustedAuthservID)}})
+		}
+		return s
 	})
 }

internal/control/stage3admin_test.go added +70

@@ -0,0 +1,70 @@
	1	package control
	2
	3	import (
	4	"regexp"
	5	"strings"
	6	"testing"
	7
	8	"gitbay.org/gitbay/internal/store"
	9	)
	10
	11	var diskBytes = regexp.MustCompile(`\t\d{4,}\t\|\d+\.\d KiB`)
	12
	13	// adminFixture is the work fixture with alice as an instance admin, a
	14	// second account, and a closed merge request to prune.
	15	func adminFixture(t testing.T) (store.Store, store.Repo, store.User, string) {
	16	t.Helper()
	17	st, repo, u, root, _ := workFixture(t)
	18	if err := st.SetUserAdmin(u.ID, true); err != nil {
	19	t.Fatal(err)
	20	}
	21	u.IsAdmin = true
	22	dispatchIn(t, st, u, root, "", "admin", "user", "create", "bob")
	23	dispatchIn(t, st, u, root, "", "mr", "close", repo.Path(), "1")
	24	return st, repo, u, root
	25	}
	26
	27	func TestAdminPlainPinned(t *testing.T) {
	28	st, repo, u, root := adminFixture(t)
	29	for name, argv := range map[string][]string{
	30	"admin-user-list": {"admin", "user", "list"},
	31	"admin-user-show": {"admin", "user", "show", "alice"},
	32	"admin-runners": {"admin", "runners"},
	33	"admin-repo-list": {"admin", "repo", "list"},
	34	"admin-stats": {"admin", "stats"},
	35	"admin-mail-inbound-check": {"admin", "mail", "inbound", "check"},
	36	} {
	37	got := dispatchIn(t, st, u, root, "", argv...)
	38	// A repository's size on disk moves by a few bytes between runs.
	39	got = diskBytes.ReplaceAllString(got, "<size>")
	40	pinPlain(t, name, got)
	41	}
	42	pinPlain(t, "admin-mr-prune", dispatchIn(t, st, u, root, "", "admin", "mr", "prune", repo.Path(), "1", "--yes"))
	43	}
	44
	45	func TestAdminScreens(t *testing.T) {
	46	st, repo, u, root := adminFixture(t)
	47	for _, tc := range []struct {
	48	argv []string
	49	want []string
	50	}{
	51	{[]string{"admin", "user", "list"}, []string{"Accounts (3)\n", "alice", "bob", "admin"}},
	52	{[]string{"admin", "user", "show", "alice"}, []string{"User:", "alice", "active", "gitbay admin user demote alice"}},
	53	{[]string{"admin", "runners"}, []string{"Queue:", "0 pending"}},
	54	{[]string{"admin", "repo", "list"}, []string{"Repositories (1)\n", "alice/app"}},
	55	{[]string{"admin", "stats"}, []string{"Users:", "2", "Repos:", "Disk:"}},
	56	{[]string{"admin", "mail", "inbound", "check"}, []string{"Inbound: off\n"}},
	57	{[]string{"admin", "mr", "prune", repo.Path(), "1", "--yes"}, []string{"Pruned (1)\n", "!1", "already gone"}},
	58	} {
	59	out := atTerminalIn(t, st, u, root, tc.argv...)
	60	for _, w := range tc.want {
	61	if !strings.Contains(out, w) {
	62	t.Errorf("%v: missing %q in:\n%s", tc.argv, w, out)
	63	}
	64	}
	65	if strings.Contains(tc.argv[1], "mail") \|\| tc.argv[1] == "runners" {
	66	continue
	67	}
	68	checkLegend(t, out)
	69	}
	70	}

internal/control/testdata/plain/admin-mail-inbound-check.txt added +1

	@@ -0,0 +1 @@
		1	inbound mail is off ([mail.inbound] enabled = false)

internal/control/testdata/plain/admin-mr-prune.txt added +1

	@@ -0,0 +1 @@
		1	!1 already gone

internal/control/testdata/plain/admin-repo-list.txt added +1

	@@ -0,0 +1 @@
		1	alice/app public<size><time>

internal/control/testdata/plain/admin-runners.txt added +5

@@ -0,0 +1,5 @@
	1	pending 0
	2	claimed 24h 0
	3	wait avg 0s
	4	wait max 0s
	5	reaped 24h 0

internal/control/testdata/plain/admin-stats.txt added +11

@@ -0,0 +1,11 @@
	1	users 3
	2	orgs 0
	3	repos 1
	4	issues 1 (1 open)
	5	MRs 1 (0 open)
	6	database 0 B
	7	repositories <size>
	8	lfs 0 B
	9
	10	repos:
	11	alice/app <size>

internal/control/testdata/plain/admin-user-list.txt added +3

@@ -0,0 +1,3 @@
	1	alice active admin <time>
	2	bob active <time>
	3	gitbay-bot active <time>

internal/control/testdata/plain/admin-user-show.txt added +6

@@ -0,0 +1,6 @@
	1	alice active
	2
	3	admin yes
	4	created <time>
	5	repos 1
	6	web sessions 0

Commit 7f6601266e

Commit `7f6601266e`