Feature 57 (config and provisioning): modules declare config and provisions, their files rendered from templates; synced with main (issues of feature 57, 874)
This commit is contained in:
@@ -0,0 +1,348 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"golang.org/x/crypto/nacl/box"
|
||||
|
||||
"gitea/internal/forgehttp"
|
||||
)
|
||||
|
||||
const (
|
||||
// ToolName is the issuing tool the vault asks (the offer's credential tool in module.json).
|
||||
ToolName = "gitea_agent_token"
|
||||
// Provision is what the tool issues: the forge's read credential, one per agent.
|
||||
Provision = "gitea-read"
|
||||
// Holder is the one consuming module answered: the agent's own module, which places the credential in the
|
||||
// agent's home (ADR 0365 §4, ADR 0266). A holder of another module is not answered and keeps nothing.
|
||||
Holder = "claude-code"
|
||||
// TokenName is the token's name in the agent account's list, found and deleted by it at the next mint.
|
||||
TokenName = "mesh-agent-read"
|
||||
// AccountPrefix names an agent's account for its node (ADR 0365 §1).
|
||||
AccountPrefix = "agent-"
|
||||
// vaultModule is the vault's module: its account is `<node>.mesh-vault` (ADR 0259 §8's runs-as).
|
||||
vaultModule = "mesh-vault"
|
||||
// deadline bounds one call, inside the vault's ask.
|
||||
deadline = 45 * time.Second
|
||||
)
|
||||
|
||||
// TokenScopes are the only scopes an agent's token carries (ADR 0365 §4, §5): it reads repositories and nothing
|
||||
// else, so the forge refuses it a push, a comment, a token of its own and any administration — whatever team the
|
||||
// account is in.
|
||||
var TokenScopes = []string{"read:repository"}
|
||||
|
||||
var nodeName = regexp.MustCompile(`^[a-z0-9][a-z0-9-]{0,31}$`)
|
||||
|
||||
// fromTheVault refuses every caller but the vault's own account (ADR 0349 clause 10): whoever else could call this
|
||||
// tool would hold every agent's credential.
|
||||
func fromTheVault(caller string) error {
|
||||
node, module, ok := strings.Cut(caller, ".")
|
||||
if ok && module == vaultModule && nodeName.MatchString(node) {
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("%s answers the vault alone (novox/hq ADR 0349 clause 10, ADR 0365); %q is not the vault, and "+
|
||||
"nothing was minted", ToolName, caller)
|
||||
}
|
||||
|
||||
// HolderAsk is one holder the vault named.
|
||||
type HolderAsk struct {
|
||||
Node string `json:"node"`
|
||||
Module string `json:"module"`
|
||||
}
|
||||
|
||||
// Ask is one call: the holders, and the key to seal each answer to.
|
||||
type Ask struct {
|
||||
SealTo [32]byte
|
||||
Holders []HolderAsk
|
||||
}
|
||||
|
||||
// readAsk reads the call's arguments, refusing anything that is not the vault's per-holder ask.
|
||||
func readAsk(args map[string]any) (Ask, error) {
|
||||
if p, _ := args["provision"].(string); p != Provision {
|
||||
return Ask{}, fmt.Errorf("%s issues %s alone, not %q; nothing was minted", ToolName, Provision, p)
|
||||
}
|
||||
key, _ := args["seal_to"].(string)
|
||||
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(key))
|
||||
if err != nil || len(raw) != 32 {
|
||||
return Ask{}, errors.New("seal_to is not the key of a call; nothing was minted")
|
||||
}
|
||||
var out Ask
|
||||
copy(out.SealTo[:], raw)
|
||||
list, ok := args["holders"].([]any)
|
||||
if !ok || len(list) == 0 {
|
||||
return Ask{}, fmt.Errorf("%s answers a value for each holder, and none was named; nothing was minted", ToolName)
|
||||
}
|
||||
seen := map[HolderAsk]bool{}
|
||||
for _, item := range list {
|
||||
m, _ := item.(map[string]any)
|
||||
node, _ := m["node"].(string)
|
||||
module, _ := m["module"].(string)
|
||||
h := HolderAsk{Node: strings.TrimSpace(node), Module: strings.TrimSpace(module)}
|
||||
if h.Node == "" || h.Module == "" || seen[h] {
|
||||
return Ask{}, errors.New("each holder is a node and a module, named once; nothing was minted")
|
||||
}
|
||||
seen[h] = true
|
||||
out.Holders = append(out.Holders, h)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Minter mints the agents' tokens with the administrator's login, which sets the forge up and nothing else (ADR
|
||||
// 0365 §2).
|
||||
type Minter struct {
|
||||
Forge forgehttp.Client
|
||||
// Node is the forge's own machine: a holder there also reaches the forge at Forge.URL.
|
||||
Node string
|
||||
// OriginsFile holds the forge's public origins, one per line (https://<its route's name>): the origins every
|
||||
// holder's credential is for.
|
||||
OriginsFile string
|
||||
// Password makes the password an agent's account is created with: random, sent once and kept nowhere.
|
||||
Password func() string
|
||||
Log func(format string, a ...any)
|
||||
}
|
||||
|
||||
// MinterFromEnv is the minter as the manifest hands it to this bundle. It builds the administrator's client itself:
|
||||
// the module's words reach all its bundles, and a word naming another bundle's token must not make this one act as
|
||||
// another account.
|
||||
func MinterFromEnv() (*Minter, error) {
|
||||
m := &Minter{
|
||||
Forge: forgehttp.Client{URL: strings.TrimRight(os.Getenv("MESH_GITEA_URL"), "/"),
|
||||
User: os.Getenv("MESH_GITEA_ADMIN_USER"), PasswordFile: os.Getenv("MESH_GITEA_ADMIN_PASSWORD_FILE"),
|
||||
Timeout: 20 * time.Second},
|
||||
Node: os.Getenv("MESH_NODE"),
|
||||
OriginsFile: os.Getenv("MESH_GITEA_ORIGINS_FILE"),
|
||||
}
|
||||
var missing []string
|
||||
for _, kv := range [][2]string{{"MESH_GITEA_URL", m.Forge.URL}, {"MESH_GITEA_ADMIN_USER", m.Forge.User},
|
||||
{"MESH_GITEA_ADMIN_PASSWORD_FILE", m.Forge.PasswordFile}, {"MESH_GITEA_ORIGINS_FILE", m.OriginsFile}} {
|
||||
if kv[1] == "" {
|
||||
missing = append(missing, kv[0])
|
||||
}
|
||||
}
|
||||
if len(missing) > 0 {
|
||||
return nil, fmt.Errorf("the forge cannot be reached: %s not set by the manifest; nothing was minted", strings.Join(missing, ", "))
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// Sealed is one holder's credential as the vault takes it.
|
||||
type Sealed struct {
|
||||
Node string `json:"node"`
|
||||
Module string `json:"module"`
|
||||
Sealed string `json:"sealed"`
|
||||
}
|
||||
|
||||
// Answer is what the tool answers: a sealed credential for each holder answered, and why each other was not. Never
|
||||
// a token.
|
||||
type Answer struct {
|
||||
Holders []Sealed `json:"holders"`
|
||||
Skipped map[string]string `json:"skipped,omitempty"`
|
||||
}
|
||||
|
||||
// one call at a time: a mint deletes the account's token from before, and two at once would delete each other's.
|
||||
var minting sync.Mutex
|
||||
|
||||
// Answer mints each holder's token and seals its credential lines. A holder that is not an agent's module is not
|
||||
// answered; a failure for one holder fails the call, so the vault keeps nothing rather than a part.
|
||||
func (m *Minter) Answer(ask Ask) (Answer, error) {
|
||||
minting.Lock()
|
||||
defer minting.Unlock()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), deadline)
|
||||
defer cancel()
|
||||
origins, err := m.origins()
|
||||
if err != nil {
|
||||
return Answer{}, err
|
||||
}
|
||||
out := Answer{Holders: []Sealed{}}
|
||||
skip := func(h HolderAsk, why string) {
|
||||
if out.Skipped == nil {
|
||||
out.Skipped = map[string]string{}
|
||||
}
|
||||
out.Skipped[h.Module+" on "+h.Node] = why
|
||||
}
|
||||
for _, h := range ask.Holders {
|
||||
if h.Module != Holder {
|
||||
skip(h, fmt.Sprintf("only %s places the forge's read credential, in its agent's home (ADR 0365 §4)", Holder))
|
||||
continue
|
||||
}
|
||||
if !nodeName.MatchString(h.Node) {
|
||||
skip(h, "not a machine's name an account can be named for")
|
||||
continue
|
||||
}
|
||||
reach := origins
|
||||
if h.Node == m.Node {
|
||||
reach = append(append([]string{}, origins...), m.Forge.URL)
|
||||
}
|
||||
if len(reach) == 0 {
|
||||
skip(h, "the forge names no origin it is reached at from that machine")
|
||||
continue
|
||||
}
|
||||
account := AccountPrefix + h.Node
|
||||
if err := m.ensureAccount(ctx, account); err != nil {
|
||||
return Answer{}, err
|
||||
}
|
||||
token, err := m.mint(ctx, account)
|
||||
if err != nil {
|
||||
return Answer{}, err
|
||||
}
|
||||
lines, err := credentialLines(account, token, reach)
|
||||
token = ""
|
||||
if err != nil {
|
||||
return Answer{}, err
|
||||
}
|
||||
sealed, err := box.SealAnonymous(nil, []byte(lines), &ask.SealTo, rand.Reader)
|
||||
lines = ""
|
||||
if err != nil {
|
||||
return Answer{}, fmt.Errorf("the credential for %s could not be sealed: %w", account, err)
|
||||
}
|
||||
out.Holders = append(out.Holders, Sealed{Node: h.Node, Module: h.Module, Sealed: base64.StdEncoding.EncodeToString(sealed)})
|
||||
m.say("minted a read token for %s (%s on %s); its token from before is deleted", account, h.Module, h.Node)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// origins are the forge's public origins, as its route names them.
|
||||
func (m *Minter) origins() ([]string, error) {
|
||||
raw, err := os.ReadFile(m.OriginsFile)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("the forge's origins cannot be read (%s); nothing was minted: %w", m.OriginsFile, err)
|
||||
}
|
||||
var out []string
|
||||
for _, line := range strings.Split(string(raw), "\n") {
|
||||
line = strings.TrimRight(strings.TrimSpace(line), "/")
|
||||
if line == "" {
|
||||
continue
|
||||
}
|
||||
u, err := url.Parse(line)
|
||||
if err != nil || (u.Scheme != "https" && u.Scheme != "http") || u.Host == "" || u.User != nil || u.Path != "" {
|
||||
return nil, fmt.Errorf("%s names %q, which is not an origin (scheme://host); nothing was minted", m.OriginsFile, line)
|
||||
}
|
||||
out = append(out, line)
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// credentialLines are the lines of git's credential store for one account at each origin: what the agent's module
|
||||
// places, and git reads by protocol and host.
|
||||
func credentialLines(account, token string, origins []string) (string, error) {
|
||||
seen := map[string]bool{}
|
||||
var lines []string
|
||||
for _, o := range origins {
|
||||
u, err := url.Parse(strings.TrimRight(o, "/"))
|
||||
if err != nil || u.Host == "" {
|
||||
return "", fmt.Errorf("%q is not an origin", o)
|
||||
}
|
||||
u.Path, u.RawQuery, u.Fragment = "", "", ""
|
||||
u.User = url.UserPassword(account, token)
|
||||
if line := u.String(); !seen[line] {
|
||||
seen[line] = true
|
||||
lines = append(lines, line)
|
||||
}
|
||||
}
|
||||
sort.Strings(lines)
|
||||
return strings.Join(lines, "\n") + "\n", nil
|
||||
}
|
||||
|
||||
// gitea's account as the admin reads it.
|
||||
type forgeUser struct {
|
||||
IsAdmin bool `json:"is_admin"`
|
||||
Active bool `json:"active"`
|
||||
ProhibitLogin bool `json:"prohibit_login"`
|
||||
Restricted bool `json:"restricted"`
|
||||
}
|
||||
|
||||
// ensureAccount makes the agent's account, plain, when there is none, and puts back what was changed by hand: never
|
||||
// an administrator, active, able to use its token. It adds it to no team: what it may read beyond public
|
||||
// repositories is the operator's to grant (ADR 0365 §3).
|
||||
func (m *Minter) ensureAccount(ctx context.Context, account string) error {
|
||||
var u forgeUser
|
||||
err := m.Forge.GetJSON(ctx, "/api/v1/users/"+account, &u)
|
||||
switch {
|
||||
case errors.Is(err, forgehttp.ErrNotFound):
|
||||
password := m.password()
|
||||
err := m.Forge.SendJSON(ctx, http.MethodPost, "/api/v1/admin/users", map[string]any{
|
||||
"username": account, "email": account + "@noreply.localhost", "password": password,
|
||||
"must_change_password": false, "visibility": "private",
|
||||
}, nil)
|
||||
password = ""
|
||||
if err != nil {
|
||||
return fmt.Errorf("the account %s could not be made: %w", account, err)
|
||||
}
|
||||
m.say("made the forge account %s for that machine's agent, in no team", account)
|
||||
return nil
|
||||
case err != nil:
|
||||
return fmt.Errorf("the account %s could not be read: %w", account, err)
|
||||
}
|
||||
if u.IsAdmin || !u.Active || u.ProhibitLogin {
|
||||
if err := m.Forge.SendJSON(ctx, http.MethodPatch, "/api/v1/admin/users/"+account, map[string]any{
|
||||
"login_name": account, "source_id": 0, "admin": false, "active": true, "prohibit_login": false,
|
||||
}, nil); err != nil {
|
||||
return fmt.Errorf("the account %s could not be made a plain account again: %w", account, err)
|
||||
}
|
||||
m.say("the account %s was changed by hand (administrator %t, active %t, login prohibited %t); made a plain account again",
|
||||
account, u.IsAdmin, u.Active, u.ProhibitLogin)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type forgeToken struct {
|
||||
ID int64 `json:"id"`
|
||||
Name string `json:"name"`
|
||||
SHA1 string `json:"sha1"`
|
||||
}
|
||||
|
||||
// mint deletes every token of the account by this module's name, by its id (a name held twice is cleared, not
|
||||
// refused), and mints one with the read scope alone.
|
||||
func (m *Minter) mint(ctx context.Context, account string) (string, error) {
|
||||
var held []forgeToken
|
||||
if err := m.Forge.GetJSON(ctx, "/api/v1/users/"+account+"/tokens?limit=50", &held); err != nil {
|
||||
return "", fmt.Errorf("the tokens of %s could not be read: %w", account, err)
|
||||
}
|
||||
for _, t := range held {
|
||||
if t.Name != TokenName {
|
||||
continue
|
||||
}
|
||||
if err := m.Forge.SendJSON(ctx, http.MethodDelete, fmt.Sprintf("/api/v1/users/%s/tokens/%d", account, t.ID), nil, nil); err != nil &&
|
||||
!errors.Is(err, forgehttp.ErrNotFound) {
|
||||
return "", fmt.Errorf("the token of %s from before could not be deleted: %w", account, err)
|
||||
}
|
||||
}
|
||||
var made forgeToken
|
||||
if err := m.Forge.SendJSON(ctx, http.MethodPost, "/api/v1/users/"+account+"/tokens",
|
||||
map[string]any{"name": TokenName, "scopes": TokenScopes}, &made); err != nil {
|
||||
return "", fmt.Errorf("no token could be minted for %s: %w", account, err)
|
||||
}
|
||||
if strings.TrimSpace(made.SHA1) == "" {
|
||||
return "", fmt.Errorf("the forge answered no token for %s", account)
|
||||
}
|
||||
return strings.TrimSpace(made.SHA1), nil
|
||||
}
|
||||
|
||||
func (m *Minter) password() string {
|
||||
if m.Password != nil {
|
||||
return m.Password()
|
||||
}
|
||||
b := make([]byte, 24)
|
||||
_, _ = rand.Read(b)
|
||||
return base64.RawURLEncoding.EncodeToString(b)
|
||||
}
|
||||
|
||||
func (m *Minter) say(format string, a ...any) {
|
||||
if m.Log != nil {
|
||||
m.Log(format, a...)
|
||||
return
|
||||
}
|
||||
fmt.Fprintf(os.Stderr, format+"\n", a...)
|
||||
}
|
||||
Reference in New Issue
Block a user