Manage people and the tenancy tree, from the web and the CLI

Nothing in the tree could be renamed, moved or removed, and an approved
person stayed in the project they were first put in — from the web or
the CLI. Now:

- /admin/users is the tree, each project opening onto its people and
  keys, with approve, move, suspend, reinstate and remove for people,
  revoke for keys, and add, rename, move and remove at every level,
  plus a search over every account. Forms post and get the page back,
  so it works with no script; htmx 2.0.11 (0BSD, embedded, checked
  against npm's integrity hash) swaps only the changed part, keeping
  open projects open.
- llmgw org tree/add/rename/move/remove, users move/delete, and
  keys list --all.
- Projects, teams and organizations are named by id, path
  (Acme/platform/gateway) or unique name; users by id or email. With a
  single project --project can be left out, instead of defaulting to
  "default", which a tree built from the web does not have.

Moving a person moves the keys they made; operator keys stay with the
project. Only empty things are removed, and never a project that had a
key, since usage history refers to it.

Also: keys init no longer reparents an existing team or project;
reinstating an account with no project is refused (a rejected signup
used to come back active and fail at its first key); rejecting a
signup removes it; keys limits --budget takes whole units like the
quotas page.

Checked in headless Chrome: a move from an open project updates the
page in place, keeps the project open, and the search still filters.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilker ManapandClaude Opus 5.5 committed 2026-09-28 16:26:39 +02:00
1 parent 5141e4b138
commit 3104f4b706
21 files changed
+2081 -217

No files matched your search

+256 -59
View File
@@ -3,7 +3,9 @@ package web
import (
"context"
"errors"
"fmt"
"net/http"
"strings"
"time"
"gitea.mynodes.xyz/ilker/llmgw/internal/store"
@@ -26,36 +28,77 @@ type AccountAdmin interface {
CreateOrg(ctx context.Context, name string) (string, error)
CreateTeam(ctx context.Context, orgID, name string) (string, error)
CreateProject(ctx context.Context, teamID, name string) (string, error)
// And keeping it in shape afterwards, which used to have no interface at
// all: nothing could be renamed, moved or removed, and an approved person
// stayed in the project they were first put in.
Tree(ctx context.Context) ([]store.TreeOrg, error)
RenameOrg(ctx context.Context, id, name string) error
RenameTeam(ctx context.Context, id, name string) error
RenameProject(ctx context.Context, id, name string) error
MoveTeam(ctx context.Context, teamID, orgID string) error
MoveProject(ctx context.Context, projectID, teamID string) error
DeleteOrg(ctx context.Context, id string) error
DeleteTeam(ctx context.Context, id string) error
DeleteProject(ctx context.Context, id string) error
MoveUser(ctx context.Context, userID, projectID string) (int, error)
DeleteUser(ctx context.Context, userID string, at time.Time) error
AllKeys(ctx context.Context) ([]store.KeyRow, error)
RevokeKey(ctx context.Context, id string, at time.Time) error
}
// userRow is an account as the page shows it: with where it is, not an id.
type userRow struct {
store.User
ProjectPath string
}
// keyRow is a key as the page shows it.
type keyRow struct {
store.KeyRow
State string
}
type adminUsersData struct {
Pending []store.User
Active []store.User
Accounts []userRow
Tree []store.TreeOrg
// People and Keys are keyed by project id.
People map[string][]userRow
Keys map[string][]keyRow
Projects []store.ProjectPath
Orgs []store.Org
Teams []store.TeamPath
Message string
Error string
CSRF string
Version string
Now string
// Open is the project whose section is shown expanded: the one just acted
// on, so the result of a change is in view without the reader hunting for
// it. Scripted pages keep every open section open; this is for the rest.
Open string
AdminID string
Message string
Error string
CSRF string
Version string
Now string
// HasMirror and HasQuotas keep the nav from offering a page that was never
// mounted.
HasMirror bool
HasQuotas bool
}
// RegisterAdminUsers mounts account administration under /admin/users.
// RegisterAdminUsers mounts account and tenancy administration under
// /admin/users.
//
// What is here and what is not is the whole design. Approving and suspending
// are the work an operator does constantly and should not need a terminal for.
// Making someone an admin, resetting a password and issuing keys on another
// person's behalf are not here: each of them turns a stolen admin session into
// more than it was — more access, or somebody else's account — and each is rare
// enough that a shell is no hardship.
// What is here and what is not is the whole design. Approving, suspending,
// moving people and keeping the tree in shape are the work an operator does
// constantly and should not need a terminal for. Making someone an admin,
// resetting a password and issuing keys on another person's behalf are not
// here: each of them turns a stolen admin session into more than it was —
// more access, or somebody else's account — and each is rare enough that a
// shell is no hardship. Revoking a key is here, because it only ever takes
// access away.
func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
mux.HandleFunc("GET /admin/users", p.adminOnly(func(w http.ResponseWriter, r *http.Request, admin store.User) {
p.renderUsers(w, r, s, "", "")
p.renderUsers(w, r, s, admin, "", "", r.URL.Query().Get("open"))
}))
mux.HandleFunc("POST /admin/users/{id}/approve", p.adminAction(s,
@@ -67,7 +110,7 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
if err := s.ApproveUser(ctx, id, project, admin.Email, time.Now()); err != nil {
return "", err
}
return "approved into " + project, nil
return "approved into " + projectPath(ctx, s, project), nil
}))
mux.HandleFunc("POST /admin/users/{id}/suspend", p.adminAction(s,
@@ -88,17 +131,47 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
return "suspended, and signed out everywhere", nil
}))
// The tenancy tree. Creating a container is not granting access: nobody can
// use one until an account is approved into it, which is the step above and
// already lives here. What is still not here is limits — raising a budget
// is a financial act, and a stolen session must not be able to perform one.
mux.HandleFunc("POST /admin/tenancy/org", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
id, err := s.CreateOrg(ctx, r.FormValue("name"))
mux.HandleFunc("POST /admin/users/{id}/reinstate", p.adminAction(s,
func(ctx context.Context, _ store.User, id string, _ *http.Request) (string, error) {
if err := s.SetUserState(ctx, id, store.UserActive); err != nil {
return "", err
}
return "reinstated", nil
}))
mux.HandleFunc("POST /admin/users/{id}/move", p.adminAction(s,
func(ctx context.Context, _ store.User, id string, r *http.Request) (string, error) {
project := r.FormValue("project")
if project == "" {
return "", errors.New("choose the project they go to")
}
moved, err := s.MoveUser(ctx, id, project)
if err != nil {
return "", err
}
return "organization " + r.FormValue("name") + " created as " + id, nil
return fmt.Sprintf("moved to %s, with %s", projectPath(ctx, s, project), plural(moved, "key", "keys")), nil
}))
mux.HandleFunc("POST /admin/users/{id}/delete", p.adminAction(s,
func(ctx context.Context, admin store.User, id string, _ *http.Request) (string, error) {
if id == admin.ID {
return "", errors.New("you cannot remove your own account")
}
if err := s.DeleteUser(ctx, id, time.Now()); err != nil {
return "", err
}
return "removed; their keys are revoked", nil
}))
// The tenancy tree. Creating a container is not granting access: nobody can
// use one until an account is approved into it.
mux.HandleFunc("POST /admin/tenancy/org", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
_, err := s.CreateOrg(ctx, r.FormValue("name"))
if err != nil {
return "", err
}
return "organization " + r.FormValue("name") + " created", nil
}))
mux.HandleFunc("POST /admin/tenancy/team", p.tenancyAction(s,
@@ -107,11 +180,11 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
if org == "" {
return "", errors.New("choose the organization this team belongs to")
}
id, err := s.CreateTeam(ctx, org, r.FormValue("name"))
_, err := s.CreateTeam(ctx, org, r.FormValue("name"))
if err != nil {
return "", err
}
return "team " + r.FormValue("name") + " created as " + id, nil
return "team " + r.FormValue("name") + " created", nil
}))
mux.HandleFunc("POST /admin/tenancy/project", p.tenancyAction(s,
@@ -124,16 +197,104 @@ func (p *AccountPages) RegisterAdminUsers(mux *http.ServeMux, s AccountAdmin) {
if err != nil {
return "", err
}
return "project " + r.FormValue("name") + " created as " + id, nil
r.Form.Set("open", id)
return "project " + r.FormValue("name") + " created", nil
}))
mux.HandleFunc("POST /admin/users/{id}/reinstate", p.adminAction(s,
func(ctx context.Context, _ store.User, id string, _ *http.Request) (string, error) {
if err := s.SetUserState(ctx, id, store.UserActive); err != nil {
mux.HandleFunc("POST /admin/tenancy/{kind}/{id}/rename", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
id, name := r.PathValue("id"), strings.TrimSpace(r.FormValue("name"))
var err error
switch r.PathValue("kind") {
case "org":
err = s.RenameOrg(ctx, id, name)
case "team":
err = s.RenameTeam(ctx, id, name)
case "project":
err = s.RenameProject(ctx, id, name)
default:
return "", errors.New("nothing of that kind")
}
if err != nil {
return "", err
}
return "reinstated", nil
return "renamed to " + name, nil
}))
mux.HandleFunc("POST /admin/tenancy/{kind}/{id}/move", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
id, to := r.PathValue("id"), r.FormValue("to")
if to == "" {
return "", errors.New("choose where it goes")
}
switch r.PathValue("kind") {
case "team":
if err := s.MoveTeam(ctx, id, to); err != nil {
return "", err
}
return "team moved", nil
case "project":
if err := s.MoveProject(ctx, id, to); err != nil {
return "", err
}
return "project moved to " + projectPath(ctx, s, id), nil
}
return "", errors.New("only a team or a project moves")
}))
mux.HandleFunc("POST /admin/tenancy/{kind}/{id}/delete", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
id := r.PathValue("id")
var err error
switch r.PathValue("kind") {
case "org":
err = s.DeleteOrg(ctx, id)
case "team":
err = s.DeleteTeam(ctx, id)
case "project":
err = s.DeleteProject(ctx, id)
default:
return "", errors.New("nothing of that kind")
}
if err != nil {
return "", err
}
r.Form.Del("open")
return "removed", nil
}))
mux.HandleFunc("POST /admin/keys/{id}/revoke", p.tenancyAction(s,
func(ctx context.Context, r *http.Request) (string, error) {
if err := s.RevokeKey(ctx, r.PathValue("id"), time.Now()); err != nil {
return "", err
}
return "key revoked; a running server stops accepting it when its cache expires", nil
}))
}
func projectPath(ctx context.Context, s AccountAdmin, id string) string {
all, err := s.AllProjects(ctx)
if err == nil {
for _, p := range all {
if p.ID == id {
return p.Path
}
}
}
return id
}
// plainError says what a store error means to the person who caused it.
func plainError(err error) error {
switch {
case errors.Is(err, store.ErrDuplicateName):
return errors.New("there is already one of those here")
case errors.Is(err, store.ErrNotEmpty):
return fmt.Errorf("not removed: %s", strings.TrimPrefix(err.Error(), store.ErrNotEmpty.Error()+": "))
case errors.Is(err, store.ErrNotFound):
return errors.New("that is no longer there; the page was out of date")
}
return err
}
// tenancyAction wraps a change to the tree: admin session, CSRF, audit, render.
@@ -153,15 +314,15 @@ func (p *AccountPages) tenancyAction(s AccountAdmin,
}
msg, err := do(r.Context(), r)
if err != nil {
if errors.Is(err, store.ErrDuplicateName) {
err = errors.New("there is already one of those here")
}
p.log.Warn("a tenancy change was refused", "admin", admin.Email, "err", err)
p.renderUsers(w, r, s, "", err.Error())
err = plainError(err)
p.log.Warn("a tenancy change was refused", "admin", admin.Email,
"path", r.URL.Path, "err", err)
p.renderUsers(w, r, s, admin, "", err.Error(), r.FormValue("open"))
return
}
p.log.Info("the tenancy tree was changed", "admin", admin.Email, "what", msg)
p.renderUsers(w, r, s, msg, "")
p.log.Info("the tenancy tree was changed", "admin", admin.Email,
"path", r.URL.Path, "what", msg)
p.renderUsers(w, r, s, admin, msg, "", r.FormValue("open"))
})
}
@@ -185,7 +346,8 @@ func (p *AccountPages) adminOnly(
}
}
// adminAction wraps a state change: admin session, CSRF, audit line, redirect.
// adminAction wraps a change to one account: admin session, CSRF, audit line,
// render.
func (p *AccountPages) adminAction(s AccountAdmin,
do func(ctx context.Context, admin store.User, id string, r *http.Request) (string, error),
) http.HandlerFunc {
@@ -204,51 +366,86 @@ func (p *AccountPages) adminAction(s AccountAdmin,
msg, err := do(r.Context(), admin, id, r)
if err != nil {
err = plainError(err)
// Logged at warn whether it worked or not: a refused administrative
// action is as worth knowing about as one that went through.
p.log.Warn("an administrative action was refused",
"admin", admin.Email, "subject", subject, "err", err)
p.renderUsers(w, r, s, "", err.Error())
p.renderUsers(w, r, s, admin, "", subject+": "+err.Error(), r.FormValue("open"))
return
}
p.log.Info("an account was changed",
"admin", admin.Email, "subject", subject, "what", msg)
p.renderUsers(w, r, s, subject+" "+msg, "")
p.renderUsers(w, r, s, admin, subject+" "+msg, "", r.FormValue("open"))
})
}
func (p *AccountPages) renderUsers(w http.ResponseWriter, r *http.Request,
s AccountAdmin, msg, errMsg string,
s AccountAdmin, admin store.User, msg, errMsg, open string,
) {
ctx := r.Context()
d := adminUsersData{
Message: msg, Error: errMsg,
Message: msg, Error: errMsg, Open: open, AdminID: admin.ID,
CSRF: csrfFor(r),
Version: p.version,
HasMirror: p.hasMirror,
HasQuotas: p.hasQuotas,
Now: time.Now().UTC().Format(time.RFC3339),
People: map[string][]userRow{},
Keys: map[string][]keyRow{},
}
all, err := s.Users(r.Context(), "")
if err != nil {
p.log.Error("could not list accounts", "err", err)
d.Error = "could not read the accounts"
}
for _, u := range all {
if u.State == store.UserPending {
d.Pending = append(d.Pending, u)
} else {
d.Active = append(d.Active, u)
var err error
logErr := func(what string, err error) {
if err != nil {
p.log.Error("could not read "+what, "err", err)
if d.Error == "" {
d.Error = "could not read " + what
}
}
}
if d.Projects, err = s.AllProjects(r.Context()); err != nil {
p.log.Error("could not list projects", "err", err)
d.Projects, err = s.AllProjects(ctx)
logErr("the projects", err)
paths := make(map[string]string, len(d.Projects))
for _, pp := range d.Projects {
paths[pp.ID] = pp.Path
}
if d.Orgs, err = s.AllOrgs(r.Context()); err != nil {
p.log.Error("could not list organizations", "err", err)
all, err := s.Users(ctx, "")
logErr("the accounts", err)
for _, u := range all {
if u.State == store.UserPending && u.ProjectID == "" {
d.Pending = append(d.Pending, u)
continue
}
row := userRow{User: u, ProjectPath: paths[u.ProjectID]}
d.Accounts = append(d.Accounts, row)
d.People[u.ProjectID] = append(d.People[u.ProjectID], row)
}
if d.Teams, err = s.AllTeams(r.Context()); err != nil {
p.log.Error("could not list teams", "err", err)
keys, err := s.AllKeys(ctx)
logErr("the keys", err)
now := time.Now()
for _, k := range keys {
d.Keys[k.ProjectID] = append(d.Keys[k.ProjectID], keyRow{KeyRow: k, State: keyState(k.Key, now)})
}
d.Tree, err = s.Tree(ctx)
logErr("the tree", err)
d.Orgs, err = s.AllOrgs(ctx)
logErr("the organizations", err)
d.Teams, err = s.AllTeams(ctx)
logErr("the teams", err)
render(w, "admin_users", d)
}
func keyState(k store.Key, now time.Time) string {
switch {
case !k.RevokedAt.IsZero():
return "revoked"
case !k.ExpiresAt.IsZero() && !now.Before(k.ExpiresAt):
return "expired"
default:
return "active"
}
}