Files
archie/internal/domain/messaging/settings.go
T
sam a89281cca8 fix(webui): attribute dashboard writes to an identity, not a literal
internal/webui hardcoded the control-plane actor as "operator:web", so every
audit row a dashboard edit wrote to resource_history named a constant rather
than an identity the repository can resolve. The identity API next door already
had the answer: the dashboard authenticates with one shared token and carries
no per-user session, so the actor is the System identity.

Both dashboard paths now derive attribution from one webAudit helper, which
also stops swallowing the request ID error that would otherwise write an empty
idempotency key.

Messaging said the same thing but only checked the sender string was non-empty
before passing it through as the actor. Its set and replace paths now resolve
the sender to an identity and record its ID, on the same resolver the identity
subcommand uses, so a sender that does not resolve cannot change settings.
2026-09-21 08:49:21 +10:00

421 lines
12 KiB
Go

package messaging
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"maps"
"sort"
"strconv"
"strings"
"time"
"github.com/samcharles93/archie-core/internal/domain/identity"
)
var (
ErrSettingsValidation = errors.New("settings validation")
ErrSettingsNotFound = errors.New("settings not found")
ErrSettingsConflict = errors.New("settings version conflict")
ErrSettingsUnavailable = errors.New("settings unavailable")
)
type SettingField struct {
Type string
Secret bool
}
type SettingDescriptor struct {
Kind string
Title string
Fields map[string]SettingField
}
type SettingResource struct {
Kind string
Version int64
Value map[string]any
Raw any
}
type SettingCommand struct {
Kind string
Value map[string]any
RawValue any
ExpectedVersion int64
Actor string
Source string
RequestID string
}
type SettingsClient interface {
Catalog(context.Context) ([]SettingDescriptor, error)
Query(context.Context, string) (SettingResource, error)
Command(context.Context, SettingCommand) (SettingResource, error)
}
type SettingsCommand struct {
client SettingsClient
identities identity.Repository
}
func NewSettingsCommand(client SettingsClient) *SettingsCommand {
return &SettingsCommand{client: client}
}
func (c *SettingsCommand) WithIdentities(repository identity.Repository) *SettingsCommand {
c.identities = repository
return c
}
const settingsUsage = "Usage: /settings [list|get <kind>|set <kind> <field>=<value> ...|replace <kind> <json>]"
func (c *SettingsCommand) Execute(ctx context.Context, actor, input string) string {
if c == nil || c.client == nil {
return "Settings are unavailable."
}
args, err := splitSettingsArgs(strings.TrimSpace(input))
if err != nil {
return "Invalid settings command: " + err.Error() + ". " + settingsUsage
}
if len(args) == 0 || args[0] == "help" {
return settingsUsage
}
switch args[0] {
case "list":
return c.list(ctx, args)
case "get":
return c.get(ctx, args)
case "set":
return c.set(ctx, actor, args)
case "identity":
return c.identity(ctx, actor, args[1:])
case "replace":
return c.replace(ctx, actor, strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(input), "replace")))
default:
return settingsUsage
}
}
// resolveActor maps a channel sender to the Archie identity the write is
// recorded against. A sender that does not resolve cannot run a command: the
// audit record names an identity or the command does not happen.
func (c *SettingsCommand) resolveActor(ctx context.Context, subject, actor string) (identity.IdentityID, string) {
if strings.TrimSpace(actor) == "" {
return "", subject + " require an authenticated Archie identity; this channel cannot resolve one."
}
if c.identities == nil {
return "", subject + " require an authenticated Archie identity; identity administration is unavailable."
}
resolved, err := c.identities.ResolveLegacyName(ctx, actor)
if err != nil {
return "", subject + " require an authenticated Archie identity; this sender did not resolve."
}
return resolved.ID, ""
}
func (c *SettingsCommand) replace(ctx context.Context, actor, input string) string {
actorID, refusal := c.resolveActor(ctx, "Settings changes", actor)
if refusal != "" {
return refusal
}
kind, raw, ok := strings.Cut(strings.TrimSpace(input), " ")
if !ok || kind == "" || strings.TrimSpace(raw) == "" {
return settingsUsage
}
if _, err := c.descriptor(ctx, kind); err != nil {
return settingsError(err)
}
current, err := c.client.Query(ctx, kind)
if err != nil {
return settingsError(err)
}
var value any
if err := json.Unmarshal([]byte(raw), &value); err != nil {
return "Settings validation failed: invalid JSON."
}
updated, err := c.client.Command(ctx, SettingCommand{Kind: kind, RawValue: value, ExpectedVersion: current.Version, Actor: string(actorID), Source: "messaging", RequestID: newSettingsRequestID()})
if err != nil {
return settingsError(err)
}
return fmt.Sprintf("Updated %s to version %d.", updated.Kind, updated.Version)
}
func (c *SettingsCommand) identity(ctx context.Context, actor string, args []string) string { //nolint:gocyclo,cyclop,funlen // command arity checks remain adjacent to spoof-sensitive dispatch
const usage = "Usage: /settings identity <list|create <kind> <name>|rename <id> <name>|suspend <id>|reactivate <id>|retire <id>>"
actorID, refusal := c.resolveActor(ctx, "Identity changes", actor)
if refusal != "" {
return refusal
}
if len(args) == 1 && args[0] == "list" {
values, listErr := c.identities.List(ctx)
if listErr != nil {
return "Identity administration is unavailable: " + listErr.Error()
}
lines := []string{"Identities:"}
for _, value := range values {
lines = append(lines, fmt.Sprintf("- %s %s %s %q", value.ID, value.Kind, value.Lifecycle, value.DisplayName))
}
return strings.Join(lines, "\n")
}
audit := identity.Audit{ActorID: actorID, Source: "messaging", RequestID: newSettingsRequestID()}
if len(args) == 3 && args[0] == "create" {
id := identity.StableID(audit.RequestID)
value, createErr := identity.New(id, identity.Kind(args[1]), args[2])
if createErr == nil {
value, createErr = c.identities.Create(ctx, value, audit)
}
if createErr != nil {
return "Identity change failed: " + createErr.Error()
}
return fmt.Sprintf("Created %s %q.", value.ID, value.DisplayName)
}
if len(args) < 2 {
return usage
}
target, getErr := c.identities.Get(ctx, identity.IdentityID(args[1]))
if getErr != nil {
return "Identity change failed: " + getErr.Error()
}
var command identity.Command
switch args[0] {
case "rename":
if len(args) != 3 {
return usage
}
command = identity.Command{Type: identity.CommandRename, DisplayName: args[2]}
case "suspend":
if len(args) != 2 {
return usage
}
command.Type = identity.CommandSuspend
case "reactivate":
if len(args) != 2 {
return usage
}
command.Type = identity.CommandReactivate
case "retire":
if len(args) != 2 {
return usage
}
command.Type = identity.CommandRetire
default:
return usage
}
updated, applyErr := c.identities.Apply(ctx, target.ID, target.Version, command, audit)
if applyErr != nil {
return "Identity change failed: " + applyErr.Error()
}
return fmt.Sprintf("%s is %s (version %d).", updated.DisplayName, updated.Lifecycle, updated.Version)
}
func (c *SettingsCommand) list(ctx context.Context, args []string) string {
if len(args) != 1 {
return settingsUsage
}
descriptors, err := c.client.Catalog(ctx)
if err != nil {
return settingsError(err)
}
sort.Slice(descriptors, func(i, j int) bool { return descriptors[i].Kind < descriptors[j].Kind })
lines := []string{"Settings:"}
for _, descriptor := range descriptors {
lines = append(lines, fmt.Sprintf("- %s — %s", descriptor.Kind, descriptor.Title))
}
return strings.Join(lines, "\n")
}
func (c *SettingsCommand) get(ctx context.Context, args []string) string {
if len(args) != 2 {
return settingsUsage
}
descriptor, err := c.descriptor(ctx, args[1])
if err != nil {
return settingsError(err)
}
resource, err := c.client.Query(ctx, args[1])
if err != nil {
return settingsError(err)
}
return renderSetting(resource, descriptor)
}
func (c *SettingsCommand) set(ctx context.Context, actor string, args []string) string {
if len(args) < 3 {
return settingsUsage
}
actorID, refusal := c.resolveActor(ctx, "Settings changes", actor)
if refusal != "" {
return refusal
}
descriptor, err := c.descriptor(ctx, args[1])
if err != nil {
return settingsError(err)
}
current, err := c.client.Query(ctx, args[1])
if err != nil {
return settingsError(err)
}
value := cloneSettingValue(current.Value)
for _, assignment := range args[2:] {
name, raw, ok := strings.Cut(assignment, "=")
field, exists := descriptor.Fields[name]
if !ok || name == "" || !exists || field.Secret {
return fmt.Sprintf("Unknown or non-editable field %q for %s.", name, descriptor.Kind)
}
parsed, parseErr := parseSettingValue(field.Type, raw)
if parseErr != nil {
return fmt.Sprintf("Invalid value for %s: %v.", name, parseErr)
}
value[name] = parsed
}
updated, err := c.client.Command(ctx, SettingCommand{Kind: current.Kind, Value: value, ExpectedVersion: current.Version, Actor: string(actorID), Source: "messaging", RequestID: newSettingsRequestID()})
if err != nil {
return settingsError(err)
}
return fmt.Sprintf("Updated %s to version %d.\n%s", updated.Kind, updated.Version, renderSetting(updated, descriptor))
}
func (c *SettingsCommand) descriptor(ctx context.Context, kind string) (SettingDescriptor, error) {
descriptors, err := c.client.Catalog(ctx)
if err != nil {
return SettingDescriptor{}, err
}
for _, descriptor := range descriptors {
if descriptor.Kind == kind {
return descriptor, nil
}
}
return SettingDescriptor{}, ErrSettingsNotFound
}
func parseSettingValue(kind, raw string) (any, error) {
switch kind {
case "boolean":
return strconv.ParseBool(raw)
case "integer":
return strconv.ParseInt(raw, 10, 64)
case "duration":
duration, err := time.ParseDuration(raw)
if err != nil {
return nil, err
}
return int64(duration / time.Second), nil
case "string":
return raw, nil
default:
return nil, fmt.Errorf("unsupported type %q", kind)
}
}
func renderSetting(resource SettingResource, descriptor SettingDescriptor) string {
if resource.Value == nil {
value, err := json.MarshalIndent(resource.Raw, "", " ")
if err != nil {
return fmt.Sprintf("%s (version %d)", resource.Kind, resource.Version)
}
return fmt.Sprintf("%s (version %d):\n%s", resource.Kind, resource.Version, value)
}
names := make([]string, 0, len(resource.Value))
for name := range resource.Value {
names = append(names, name)
}
sort.Strings(names)
lines := []string{fmt.Sprintf("%s (version %d):", resource.Kind, resource.Version)}
for _, name := range names {
field := descriptor.Fields[name]
if field.Secret || looksSecret(name) {
lines = append(lines, name+"=<redacted>")
continue
}
lines = append(lines, fmt.Sprintf("%s=%v", name, resource.Value[name]))
}
return strings.Join(lines, "\n")
}
func looksSecret(name string) bool {
name = strings.ToLower(name)
for _, marker := range []string{"secret", "password", "token", "credential", "api_key", "private_key"} {
if strings.Contains(name, marker) {
return true
}
}
return false
}
func cloneSettingValue(value map[string]any) map[string]any {
cloned := make(map[string]any, len(value))
maps.Copy(cloned, value)
return cloned
}
func newSettingsRequestID() string {
var bytes [16]byte
if _, err := rand.Read(bytes[:]); err != nil {
return fmt.Sprintf("messaging-%d", time.Now().UnixNano())
}
return "messaging-" + hex.EncodeToString(bytes[:])
}
func settingsError(err error) string {
switch {
case errors.Is(err, ErrSettingsValidation):
return "Settings validation failed: " + err.Error()
case errors.Is(err, ErrSettingsNotFound):
return "Unknown settings kind. Use /settings list."
case errors.Is(err, ErrSettingsConflict):
return "Settings version conflict; inspect the latest value and retry."
default:
return "Settings are unavailable: " + err.Error()
}
}
func splitSettingsArgs(input string) ([]string, error) {
var args []string
var current strings.Builder
var quote rune
escaped := false
flush := func() {
if current.Len() > 0 {
args = append(args, current.String())
current.Reset()
}
}
for _, char := range input {
if escaped {
current.WriteRune(char)
escaped = false
continue
}
if char == '\\' {
escaped = true
continue
}
if quote != 0 {
if char == quote {
quote = 0
} else {
current.WriteRune(char)
}
continue
}
if char == '\'' || char == '"' {
quote = char
continue
}
if char == ' ' || char == '\t' || char == '\n' {
flush()
continue
}
current.WriteRune(char)
}
if escaped || quote != 0 {
return nil, errors.New("unterminated quote or escape")
}
flush()
return args, nil
}