Commit `4bfcb3893d`

4bfcb3893d5ad29d5c6ba0725fd2291d20003e30

parent: 84e1f08f23

Verified · cmc ci/build: success ci/test: success ci/vuln: success

cmc <hello@cleberg.net> · 2026-09-04 01:01 UTC

control: named payloads for what other surfaces decode

issue create, issue and mr comment, mr create, issue show and mr show
declared their output inline or as a map, so the web type-asserted map
keys and nothing tied what a command emits to what a client reads.
output.go names them: Created, MRCreated, IssueShow, MRShow and the
ReviewOut, CheckOut and CommitOut rows inside. The web decodes into
them. JSON is unchanged.

Ref #126

Layout: unified · split

internal/control/issue.go +2 −5

 		notifyUsers(c, targets, issueSubject(repo, n, title),
 			notifyBody(c, fmt.Sprintf("opened issue #%d", n), b, fmt.Sprintf("%s/issues/%d", repo.Path(), n)))
 	}
-	return c.emit(map[string]any{"number": n}, func(w io.Writer) {
+	return c.emit(Created{Number: n}, func(w io.Writer) {
 		fmt.Fprintf(w, "created %s#%d\n", repo.Path(), n)
 	})
 }
 	for _, cm := range comments {
 		cs = append(cs, commentOut{cm.Author, cm.Body, cm.BodyFormat, cm.CreatedAt})
 	}
-	d := struct {
+	d := IssueShow{issueOut: issueToOut(issue, true), Comments: cs}
-		issueOut
-		Comments []commentOut `json:"comments,omitempty"`
-	}{issueToOut(issue, true), cs}
 	_ = repo
 	return c.emit(d, func(w io.Writer) {
 		fmt.Fprintf(w, "#%d %s [%s] by %s\n", d.Number, d.Title, d.State, d.Author)

internal/control/mr.go +12 −38

 		notifyUsers(c, targets, mrSubject(repo, n, title),
 			notifyBody(c, fmt.Sprintf("opened merge request !%d (%s -> %s)", n, source, target), b, fmt.Sprintf("%s/mrs/%d", repo.Path(), n)))
 	}
-	out := map[string]any{"number": n, "head_sha": headSHA}
+	out := MRCreated{Number: n, HeadSHA: headSHA}
-	var parent *stackRef
 	if p, ok, err := c.Store.OpenMRBySource(repo.ID, target); err == nil && ok {
-		parent = &stackRef{p.Number, p.Title}
+		out.StackedOn = &stackRef{p.Number, p.Title}
-		out["stacked_on"] = parent
 	}
 	return c.emit(out, func(w io.Writer) {
 		fmt.Fprintf(w, "created %s!%d (%s -> %s)\n", repo.Path(), n, source, target)
-		if parent != nil {
+		if out.StackedOn != nil {
-			fmt.Fprintf(w, "stacked on !%d %s\n", parent.Number, parent.Title)
+			fmt.Fprintf(w, "stacked on !%d %s\n", out.StackedOn.Number, out.StackedOn.Title)
 		}
 	})
 }
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
-	type reviewOut struct {
+	var checks []CheckOut
-		Reviewer  string `json:"reviewer"`
-		Verdict   string `json:"verdict"`
-		Stale     bool   `json:"stale"`
-		CreatedAt string `json:"created_at"`
-	}
-	type checkOut struct {
-		Context   string `json:"context"`
-		State     string `json:"state"`
-		URL       string `json:"url,omitempty"`
-		UpdatedAt string `json:"updated_at"`
-		Duration  string `json:"duration,omitempty"` // CI checks only, once finished
-	}
-	var checks []checkOut
 	for _, st := range statuses {
-		out := checkOut{Context: st.Context, State: st.State, URL: st.TargetURL, UpdatedAt: st.UpdatedAt}
+		out := CheckOut{Context: st.Context, State: st.State, URL: st.TargetURL, UpdatedAt: st.UpdatedAt}
 		if st.Duration > 0 {
 			out.Duration = st.Duration.String()
 		}
 	for _, cm := range comments {
 		cs = append(cs, commentOut{cm.Author, cm.Body, cm.BodyFormat, cm.CreatedAt})
 	}
-	var rs []reviewOut
+	var rs []ReviewOut
 	for _, r := range reviews {
-		rs = append(rs, reviewOut{r.Reviewer, r.Verdict, r.Stale, r.CreatedAt})
+		rs = append(rs, ReviewOut{r.Reviewer, r.Verdict, r.Stale, r.CreatedAt})
 	}
 	// The commits this MR carries: base..head, the diff's range.
-	type commitOut struct {
+	var commits []CommitOut
-		SHA     string `json:"sha"`
-		Subject string `json:"subject"`
-	}
-	var commits []commitOut
 	dir := RepoDir(c.Cfg.Server.Root, repo.OwnerName, repo.Name)
 	base := mr.MergedBase
 	if base == "" {
 						subject = parsed.Subject
 					}
 				}
-				commits = append(commits, commitOut{sha, subject})
+				commits = append(commits, CommitOut{sha, subject})
 			}
 		}
 	}
-	d := struct {
+	d := MRShow{mrOut: mrToOut(repo, mr, true), Checks: checks, Combined: combined,
-		mrOut
+		UnresolvedThreads: unresolved, Commits: commits, Comments: cs, Reviews: rs}
-		Checks            []checkOut   `json:"checks,omitempty"`
-		Combined          string       `json:"checks_combined,omitempty"`
-		UnresolvedThreads int          `json:"unresolved_threads,omitempty"`
-		Commits           []commitOut  `json:"commits,omitempty"`
-		Comments          []commentOut `json:"comments,omitempty"`
-		Reviews           []reviewOut  `json:"reviews,omitempty"`
-	}{mrToOut(repo, mr, true), checks, combined, unresolved, commits, cs, rs}
 	d.StackedOn, d.Stacked = stackOf(c, repo, mr)
 	return c.emit(d, func(w io.Writer) {
 		fmt.Fprintf(w, "!%d %s [%s] by %s\n%s -> %s @ %.10s\n", d.Number, d.Title, d.State, d.Author, d.Source, d.TargetRef, d.HeadSHA)

internal/control/output.go added +57

@@ -0,0 +1,57 @@
	1	package control
	2
	3	// Named payloads for the commands other surfaces decode. A command used
	4	// to declare its output inline, so the web type-asserted map keys and
	5	// nothing tied what a command emits to what a client reads (#126).
	6
	7	// Created is what issue create, issue comment and mr comment emit.
	8	type Created struct {
	9	Number int64 `json:"number"`
	10	}
	11
	12	// MRCreated is what mr create emits.
	13	type MRCreated struct {
	14	Number int64 `json:"number"`
	15	HeadSHA string `json:"head_sha"`
	16	StackedOn *stackRef `json:"stacked_on,omitempty"`
	17	}
	18
	19	// IssueShow is issue show's payload: the issue and its comments.
	20	type IssueShow struct {
	21	issueOut
	22	Comments []commentOut `json:"comments,omitempty"`
	23	}
	24
	25	// MRShow is mr show's payload.
	26	type MRShow struct {
	27	mrOut
	28	Checks []CheckOut `json:"checks,omitempty"`
	29	Combined string `json:"checks_combined,omitempty"`
	30	UnresolvedThreads int `json:"unresolved_threads,omitempty"`
	31	Commits []CommitOut `json:"commits,omitempty"`
	32	Comments []commentOut `json:"comments,omitempty"`
	33	Reviews []ReviewOut `json:"reviews,omitempty"`
	34	}
	35
	36	// ReviewOut is one review on a merge request.
	37	type ReviewOut struct {
	38	Reviewer string `json:"reviewer"`
	39	Verdict string `json:"verdict"`
	40	Stale bool `json:"stale"`
	41	CreatedAt string `json:"created_at"`
	42	}
	43
	44	// CheckOut is one commit status on a merge request head.
	45	type CheckOut struct {
	46	Context string `json:"context"`
	47	State string `json:"state"`
	48	URL string `json:"url,omitempty"`
	49	UpdatedAt string `json:"updated_at"`
	50	Duration string `json:"duration,omitempty"` // CI checks only, once finished
	51	}
	52
	53	// CommitOut is one commit a merge request carries.
	54	type CommitOut struct {
	55	SHA string `json:"sha"`
	56	Subject string `json:"subject"`
	57	}

internal/control/thread.go +1 −1

	@@ -110,7 +110,7 @@ func runComment(c *Ctx, args []string, t thread, noun string,
110	notifyUsers(c, parts, subject,	110	notifyUsers(c, parts, subject,
111	notifyBody(c, fmt.Sprintf("commented on %s%d", t.symbol, number), body, fmt.Sprintf("%s/%s/%d", repo.Path(), t.segment, number)))	111	notifyBody(c, fmt.Sprintf("commented on %s%d", t.symbol, number), body, fmt.Sprintf("%s/%s/%d", repo.Path(), t.segment, number)))
112	}	112	}
113	return c.emit(map[string]any{"number": number}, func(w io.Writer) {	113	return c.emit(Created{Number: number}, func(w io.Writer) {
114	fmt.Fprintf(w, "commented on %s%s%d\n", repo.Path(), t.symbol, number)	114	fmt.Fprintf(w, "commented on %s%s%d\n", repo.Path(), t.symbol, number)
115	})	115	})
116	}	116	}

internal/httpd/accounts.go +3 −2

 func (s *Server) issueCreateSubmit(w http.ResponseWriter, r *http.Request, u store.User) {
 	repoPath := r.PathValue("owner") + "/" + r.PathValue("repo")
 	title := strings.TrimSpace(r.FormValue("title"))
-	code, data, msg := s.dispatchJSON(u, []string{"issue", "create", repoPath, "--title", title, "--file", "-"}, r.FormValue("body"))
+	var created control.Created
+	code, msg := s.dispatchIntoStdin(u, []string{"issue", "create", repoPath, "--title", title, "--file", "-"}, r.FormValue("body"), &created)
 	if code != protocol.ExitOK {
 		http.Error(w, msg, statusForExit(code))
 		return
 	}
-	n := int64(data["number"].(float64))
+	n := created.Number
 	// Labels need write access, matching the SSH rule; the command refuses
 	// otherwise and the issue stands without them.
 	if args := fieldArgs("--add", r.FormValue("labels")); len(args) > 0 {

internal/httpd/control.go +7 −1

 }
 func (s *Server) dispatchInto(u store.User, argv []string, target any) (int, string) {
+	return s.dispatchIntoStdin(u, argv, "", target)
+}
+// dispatchIntoStdin is dispatchInto with a body on stdin, decoding the
+// command's named payload rather than a map (#126).
+func (s *Server) dispatchIntoStdin(u store.User, argv []string, stdin string, target any) (int, string) {
 	var stdout, stderr bytes.Buffer
 	ctx := &control.Ctx{
 		User:   u,
 		Scope:  "full",
 		Store:  s.st,
 		Cfg:    s.cfg,
-		Stdin:  strings.NewReader(""),
+		Stdin:  strings.NewReader(stdin),
 		Stdout: &stdout,
 		Stderr: &stderr,
 		JSON:   true,

internal/httpd/mractions.go +4 −4

 	"strconv"
 	"strings"
+	"gitbay.org/gitbay/internal/control"
 	"gitbay.org/gitbay/internal/gitutil"
 	"gitbay.org/gitbay/internal/store"
 )
 	if body != "" {
 		argv = append(argv, "--body", body)
 	}
-	data, msg, ok := s.runControlJSON(u, argv)
+	var created control.MRCreated
-	if !ok {
+	if msg, ok := s.runControlInto(u, argv, &created); !ok {
 		back(msg)
 		return
 	}
-	n, _ := data["number"].(float64)
+	http.Redirect(w, r, fmt.Sprintf("/%s/mrs/%d", p.Repo.Path(), created.Number), http.StatusSeeOther)
-	http.Redirect(w, r, fmt.Sprintf("/%s/mrs/%d", p.Repo.Path(), int64(n)), http.StatusSeeOther)
 }

Commit 4bfcb3893d

Commit `4bfcb3893d`