feat(judgement): impact, provenance, timing and cost guards from data, with business hours, blackouts and action budgets as settings (#1988)

This commit is contained in:
sam committed 2026-11-16 09:38:34 +11:00
1 parent 82cfc1de5b
commit ef62dcc97a
15 files changed
+941 -20

No files matched your search

+19 -12
View File
@@ -87,19 +87,20 @@ func Run(ctx context.Context, configPath string) error {
engine := runs.New(db, log.With("module", "runs"), runs.Options{Owner: owner()}) engine := runs.New(db, log.With("module", "runs"), runs.Options{Owner: owner()})
// A workflow takes its context from the run handle, as a handler takes it // A workflow takes its context from the run handle, as a handler takes it
// from the request. // from the request.
judge, classes, policies := newJudgement(db, log, conns, settings) classes := judgement.NewClasses(db, log.With("module", "judgement"), orgID)
// An approval request is carried by deliveries, and its answer wakes the run // An approval request is carried by deliveries, and its answer wakes the run
// that is waiting on it. // that is waiting on it.
allow := approvals.NewModule(db, log.With("module", "approvals"), orgID, tell, engine, classes, settings, settings) allow := approvals.NewModule(db, log.With("module", "approvals"), orgID, tell, engine, classes, settings, settings)
allow.Routes(mux, guard) allow.Routes(mux, guard)
classes.Routes(mux, guard, allow) classes.Routes(mux, guard, allow)
policies := judgement.NewPolicies(db, log.With("module", "judgement"), orgID)
policies.Routes(mux, guard) policies.Routes(mux, guard)
remembered := memory.NewModule(db, orgID)
engine.Register("investigate", 1, runs.Investigate(settings, conns, judge, allow, tell, remembered)) //nolint:contextcheck // see above
// An answer a channel delivers is an event, and settles its request. // An answer a channel delivers is an event, and settles its request.
hear := events.NewModule(db, log.With("module", "events"), orgID, conns, engine, allow) hear := events.NewModule(db, log.With("module", "events"), orgID, conns, engine, allow)
hear.Routes(mux, guard) hear.Routes(mux, guard)
judge := newJudgement(db, log, conns, classes, policies, settings, hear)
remembered := memory.NewModule(db, orgID)
engine.Register("investigate", 1, runs.Investigate(settings, conns, judge, allow, tell, remembered)) //nolint:contextcheck // see above
engine.Routes(mux, guard, orgID, hear, judge, allow) engine.Routes(mux, guard, orgID, hear, judge, allow)
dashboard.Routes(mux, ui.DistDirFS) dashboard.Routes(mux, ui.DistDirFS)
@@ -123,16 +124,22 @@ func work(ctx context.Context, loops ...func(context.Context)) func() {
return workers.Wait return workers.Wait
} }
// newJudgement returns the judgement module and the action classes its // newJudgement returns the judgement module with its hard rules, data guards
// precedent guard reads, and the policy sets. A failed action tightens its class. // and change-request rules. A failed action tightens its class.
func newJudgement(db *sqlx.DB, log *slog.Logger, conns *connectors.Module, freezes judgement.Freezes) (*judgement.Module, *judgement.Classes, *judgement.Policies) { func newJudgement(db *sqlx.DB, log *slog.Logger, conns *connectors.Module, classes *judgement.Classes, policies *judgement.Policies, settings *governance.Module, heard judgement.Events) *judgement.Module {
classes := judgement.NewClasses(db, log.With("module", "judgement"), orgID) guards := []judgement.Guard{
policies := judgement.NewPolicies(db, log.With("module", "judgement"), orgID) judgement.Impact{Lookup: judgement.NoTargetFacts{}},
judge := judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, []judgement.HardRule{policies}, judgement.Reversibility{},
[]judgement.Guard{judgement.Reversibility{}, judgement.Precedent{Classes: classes}, judgement.Freeze{Freezes: freezes}}, classes) judgement.Precedent{Classes: classes},
judgement.Provenance{Events: heard},
judgement.Timing{Calendar: settings},
judgement.Cost{Budgets: settings, Counts: judgement.NewSpend(db, orgID)},
judgement.Freeze{Freezes: settings},
}
judge := judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, []judgement.HardRule{policies}, guards, classes)
judge.UseExtensions(conns) judge.UseExtensions(conns)
judge.UseChangeRules(policies) judge.UseChangeRules(policies)
return judge, classes, policies return judge
} }
// orgID is the one organisation until hosting is multi-tenant. // orgID is the one organisation until hosting is multi-tenant.
@@ -0,0 +1,9 @@
-- +goose Up
ALTER TABLE governance.settings ADD COLUMN timing jsonb NOT NULL DEFAULT '{}';
ALTER TABLE governance.settings ADD COLUMN actions_per_run integer NOT NULL DEFAULT 10;
ALTER TABLE governance.settings ADD COLUMN actions_per_day integer NOT NULL DEFAULT 100;
-- +goose Down
ALTER TABLE governance.settings DROP COLUMN actions_per_day;
ALTER TABLE governance.settings DROP COLUMN actions_per_run;
ALTER TABLE governance.settings DROP COLUMN timing;
+53
View File
@@ -0,0 +1,53 @@
package events
import (
"context"
json "encoding/json/v2"
"strings"
"github.com/google/uuid"
)
// minFreeText is the shortest event text taken as something a person wrote.
const minFreeText = 12
// Provenance reports whether a verified source started a run, and the free
// text its event carried. Every stored event arrived through a source that
// proved its token, so a run an event started is verified and a run none
// started is not. Free text is any string with a space in it: prose a sender
// wrote, as opposed to an identifier, a path or a number.
func (m *Module) Provenance(ctx context.Context, runID uuid.UUID) (verified bool, untrusted []string, err error) {
o, ok, err := m.store.OriginOf(ctx, m.orgID, runID)
if err != nil || !ok {
return false, nil, err
}
return true, freeText(o.Fields), nil
}
// freeText returns every string in fields that reads as prose.
func freeText(fields []byte) []string {
var v any
if err := json.Unmarshal(fields, &v); err != nil {
return nil
}
var out []string
var walk func(any)
walk = func(v any) {
switch x := v.(type) {
case string:
if len(x) >= minFreeText && strings.ContainsAny(x, " \t\n") {
out = append(out, x)
}
case []any:
for _, e := range x {
walk(e)
}
case map[string]any:
for _, e := range x {
walk(e)
}
}
}
walk(v)
return out
}
+36 -3
View File
@@ -63,6 +63,13 @@ const (
maxAttemptsPerRun = 200 maxAttemptsPerRun = 200
) )
// The defaults and bounds on the action budgets.
const (
DefaultActionsPerRun = 10
DefaultActionsPerDay = 100
maxActionBudget = 10000
)
// The bounds on an approval deadline. Below a minute nobody could answer; past // The bounds on an approval deadline. Below a minute nobody could answer; past
// a month the request outlives the incident it was raised for. // a month the request outlives the incident it was raised for.
const ( const (
@@ -92,6 +99,12 @@ type Settings struct {
// Escalation is the ids of the people an unanswered request moves through, // Escalation is the ids of the people an unanswered request moves through,
// in order. // in order.
Escalation []string Escalation []string
// Timing is when changing actions may run without asking.
Timing Timing
// ActionsPerRun and ActionsPerDay are how many actions one run, and the
// organisation in a day, may take before a changing action waits for approval.
ActionsPerRun int
ActionsPerDay int
} }
// settingsRequest is the settings as the API shows and sets them. A duration // settingsRequest is the settings as the API shows and sets them. A duration
@@ -105,7 +118,10 @@ type settingsRequest struct {
AttemptsPerRun int `json:"attempts_per_run"` AttemptsPerRun int `json:"attempts_per_run"`
DefaultOwner string `json:"default_owner"` DefaultOwner string `json:"default_owner"`
// Escalation lists person ids. // Escalation lists person ids.
Escalation []string `json:"escalation"` Escalation []string `json:"escalation"`
Timing Timing `json:"timing"`
ActionsPerRun int `json:"actions_per_run"`
ActionsPerDay int `json:"actions_per_day"`
} }
func (s Settings) request() settingsRequest { func (s Settings) request() settingsRequest {
@@ -113,6 +129,7 @@ func (s Settings) request() settingsRequest {
ApprovalDeadline: s.ApprovalDeadline.String(), RaiseAfter: s.RaiseAfter, Frozen: s.Frozen, ApprovalDeadline: s.ApprovalDeadline.String(), RaiseAfter: s.RaiseAfter, Frozen: s.Frozen,
RecurrenceThreshold: s.RecurrenceThreshold, AttemptsPerRun: s.AttemptsPerRun, RecurrenceThreshold: s.RecurrenceThreshold, AttemptsPerRun: s.AttemptsPerRun,
DefaultOwner: s.DefaultOwner, Escalation: s.Escalation, DefaultOwner: s.DefaultOwner, Escalation: s.Escalation,
Timing: s.Timing, ActionsPerRun: s.ActionsPerRun, ActionsPerDay: s.ActionsPerDay,
} }
} }
@@ -177,14 +194,20 @@ func (m *Module) Settings(ctx context.Context) (Settings, error) {
return Settings{ return Settings{
ApprovalDeadline: DefaultApprovalDeadline, RaiseAfter: DefaultRaiseAfter, ApprovalDeadline: DefaultApprovalDeadline, RaiseAfter: DefaultRaiseAfter,
RecurrenceThreshold: DefaultRecurrenceThreshold, AttemptsPerRun: DefaultAttemptsPerRun, RecurrenceThreshold: DefaultRecurrenceThreshold, AttemptsPerRun: DefaultAttemptsPerRun,
Escalation: []string{}, Escalation: []string{}, Timing: Timing{}.normalised(),
ActionsPerRun: DefaultActionsPerRun, ActionsPerDay: DefaultActionsPerDay,
}, nil }, nil
} }
escalation := []string{} escalation := []string{}
if err := json.Unmarshal(jsontext.Value(row.Escalation), &escalation); err != nil { if err := json.Unmarshal(jsontext.Value(row.Escalation), &escalation); err != nil {
return Settings{}, fmt.Errorf("read escalation path: %w", err) return Settings{}, fmt.Errorf("read escalation path: %w", err)
} }
var timing Timing
if err := json.Unmarshal(jsontext.Value(row.Timing), &timing); err != nil {
return Settings{}, fmt.Errorf("read timing: %w", err)
}
return Settings{ return Settings{
Timing: timing.normalised(), ActionsPerRun: row.ActionsPerRun, ActionsPerDay: row.ActionsPerDay,
ApprovalDeadline: time.Duration(row.ApprovalDeadlineMS) * time.Millisecond, ApprovalDeadline: time.Duration(row.ApprovalDeadlineMS) * time.Millisecond,
RaiseAfter: row.RaiseAfter, RaiseAfter: row.RaiseAfter,
Frozen: row.Frozen, Frozen: row.Frozen,
@@ -277,6 +300,7 @@ func (m *Module) putSettings(w http.ResponseWriter, r *http.Request) {
ApprovalDeadline: deadline, RaiseAfter: req.RaiseAfter, Frozen: req.Frozen, ApprovalDeadline: deadline, RaiseAfter: req.RaiseAfter, Frozen: req.Frozen,
RecurrenceThreshold: req.RecurrenceThreshold, AttemptsPerRun: req.AttemptsPerRun, RecurrenceThreshold: req.RecurrenceThreshold, AttemptsPerRun: req.AttemptsPerRun,
DefaultOwner: req.DefaultOwner, Escalation: req.Escalation, DefaultOwner: req.DefaultOwner, Escalation: req.Escalation,
Timing: req.Timing.normalised(), ActionsPerRun: req.ActionsPerRun, ActionsPerDay: req.ActionsPerDay,
} }
if set.Escalation == nil { if set.Escalation == nil {
set.Escalation = []string{} set.Escalation = []string{}
@@ -300,10 +324,16 @@ func (m *Module) putSettings(w http.ResponseWriter, r *http.Request) {
httpjson.Error(w, http.StatusInternalServerError, "couldn't save the settings") httpjson.Error(w, http.StatusInternalServerError, "couldn't save the settings")
return return
} }
timing, err := json.Marshal(set.Timing)
if err != nil {
httpjson.Error(w, http.StatusInternalServerError, "couldn't save the settings")
return
}
if err := m.store.PutSettings(r.Context(), store.Settings{ if err := m.store.PutSettings(r.Context(), store.Settings{
OrgID: m.orgID, ApprovalDeadlineMS: set.ApprovalDeadline.Milliseconds(), OrgID: m.orgID, ApprovalDeadlineMS: set.ApprovalDeadline.Milliseconds(),
RaiseAfter: set.RaiseAfter, Frozen: set.Frozen, RecurrenceThreshold: set.RecurrenceThreshold, RaiseAfter: set.RaiseAfter, Frozen: set.Frozen, RecurrenceThreshold: set.RecurrenceThreshold,
AttemptsPerRun: set.AttemptsPerRun, DefaultOwner: set.DefaultOwner, Escalation: string(escalation), AttemptsPerRun: set.AttemptsPerRun, DefaultOwner: set.DefaultOwner, Escalation: string(escalation),
Timing: string(timing), ActionsPerRun: set.ActionsPerRun, ActionsPerDay: set.ActionsPerDay,
}); err != nil { }); err != nil {
m.log.ErrorContext(r.Context(), "put settings", "error", err) m.log.ErrorContext(r.Context(), "put settings", "error", err)
httpjson.Error(w, http.StatusInternalServerError, "couldn't save the settings") httpjson.Error(w, http.StatusInternalServerError, "couldn't save the settings")
@@ -328,7 +358,10 @@ func (s Settings) validate() error {
if s.AttemptsPerRun < minAttemptsPerRun || s.AttemptsPerRun > maxAttemptsPerRun { if s.AttemptsPerRun < minAttemptsPerRun || s.AttemptsPerRun > maxAttemptsPerRun {
return fmt.Errorf("attempts per run must be between %d and %d", minAttemptsPerRun, maxAttemptsPerRun) return fmt.Errorf("attempts per run must be between %d and %d", minAttemptsPerRun, maxAttemptsPerRun)
} }
return nil if s.ActionsPerRun < 1 || s.ActionsPerRun > maxActionBudget || s.ActionsPerDay < s.ActionsPerRun || s.ActionsPerDay > maxActionBudget {
return fmt.Errorf("actions per run must be at least 1, and actions per day at least that and at most %d", maxActionBudget)
}
return s.Timing.validate()
} }
// knows checks that the default owner and every person on the escalation path // knows checks that the default owner and every person on the escalation path
+12 -4
View File
@@ -78,6 +78,11 @@ type Settings struct {
Escalation string `db:"escalation"` Escalation string `db:"escalation"`
// AttemptsPerRun is how many steps an agent may take in one run. // AttemptsPerRun is how many steps an agent may take in one run.
AttemptsPerRun int `db:"attempts_per_run"` AttemptsPerRun int `db:"attempts_per_run"`
// Timing is a JSON object: business hours and blackouts.
Timing string `db:"timing"`
// ActionsPerRun and ActionsPerDay are the action budgets.
ActionsPerRun int `db:"actions_per_run"`
ActionsPerDay int `db:"actions_per_day"`
} }
// Settings returns the organisation's settings; ok is false when none were // Settings returns the organisation's settings; ok is false when none were
@@ -86,7 +91,8 @@ func (s *Store) Settings(ctx context.Context, orgID string) (Settings, bool, err
var out Settings var out Settings
err := s.db.GetContext(ctx, &out, ` err := s.db.GetContext(ctx, &out, `
SELECT org_id, approval_deadline_ms, raise_after, frozen, recurrence_threshold, SELECT org_id, approval_deadline_ms, raise_after, frozen, recurrence_threshold,
default_owner, escalation::text AS escalation, attempts_per_run default_owner, escalation::text AS escalation, attempts_per_run,
timing::text AS timing, actions_per_run, actions_per_day
FROM governance.settings WHERE org_id = $1`, orgID) FROM governance.settings WHERE org_id = $1`, orgID)
if errors.Is(err, sql.ErrNoRows) { if errors.Is(err, sql.ErrNoRows) {
return Settings{}, false, nil return Settings{}, false, nil
@@ -101,14 +107,16 @@ func (s *Store) Settings(ctx context.Context, orgID string) (Settings, bool, err
func (s *Store) PutSettings(ctx context.Context, set Settings) error { func (s *Store) PutSettings(ctx context.Context, set Settings) error {
if _, err := s.db.NamedExecContext(ctx, ` if _, err := s.db.NamedExecContext(ctx, `
INSERT INTO governance.settings (org_id, approval_deadline_ms, raise_after, frozen, recurrence_threshold, INSERT INTO governance.settings (org_id, approval_deadline_ms, raise_after, frozen, recurrence_threshold,
default_owner, escalation, attempts_per_run) default_owner, escalation, attempts_per_run, timing, actions_per_run, actions_per_day)
VALUES (:org_id, :approval_deadline_ms, :raise_after, :frozen, :recurrence_threshold, VALUES (:org_id, :approval_deadline_ms, :raise_after, :frozen, :recurrence_threshold,
:default_owner, CAST(:escalation AS jsonb), :attempts_per_run) :default_owner, CAST(:escalation AS jsonb), :attempts_per_run,
CAST(:timing AS jsonb), :actions_per_run, :actions_per_day)
ON CONFLICT (org_id) DO UPDATE ON CONFLICT (org_id) DO UPDATE
SET approval_deadline_ms = EXCLUDED.approval_deadline_ms, raise_after = EXCLUDED.raise_after, SET approval_deadline_ms = EXCLUDED.approval_deadline_ms, raise_after = EXCLUDED.raise_after,
frozen = EXCLUDED.frozen, recurrence_threshold = EXCLUDED.recurrence_threshold, frozen = EXCLUDED.frozen, recurrence_threshold = EXCLUDED.recurrence_threshold,
default_owner = EXCLUDED.default_owner, escalation = EXCLUDED.escalation, default_owner = EXCLUDED.default_owner, escalation = EXCLUDED.escalation,
attempts_per_run = EXCLUDED.attempts_per_run, updated_at = now()`, set); err != nil { attempts_per_run = EXCLUDED.attempts_per_run, timing = EXCLUDED.timing,
actions_per_run = EXCLUDED.actions_per_run, actions_per_day = EXCLUDED.actions_per_day, updated_at = now()`, set); err != nil {
return fmt.Errorf("put settings: %w", err) return fmt.Errorf("put settings: %w", err)
} }
return nil return nil
+154
View File
@@ -0,0 +1,154 @@
package governance
import (
"context"
"errors"
"fmt"
"slices"
"strings"
"time"
)
// Timing is when the organisation lets actions that change something run
// without asking. Outside business hours, or inside a blackout, they wait for
// approval. Reading is never held.
type Timing struct {
// Zone is the IANA zone business hours are read in; empty means UTC.
Zone string `json:"zone"`
// Start and End bound business hours as "15:04". Both empty means every
// hour is a business hour. End before Start spans midnight.
Start string `json:"start"`
End string `json:"end"`
// Days are the business days, as "mon" to "sun". Empty means every day.
Days []string `json:"days"`
Blackouts []Blackout `json:"blackouts"`
}
// Blackout is a window in which nothing that changes something runs unasked.
type Blackout struct {
From time.Time `json:"from"`
To time.Time `json:"to"`
Reason string `json:"reason"`
}
const clock = "15:04"
var weekdays = []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"}
// validate checks that the zone, hours, days and blackouts mean something.
func (t Timing) validate() error {
if _, err := t.location(); err != nil {
return err
}
if (t.Start == "") != (t.End == "") {
return errors.New("business hours need both a start and an end")
}
for _, c := range []string{t.Start, t.End} {
if c == "" {
continue
}
if _, err := time.Parse(clock, c); err != nil {
return fmt.Errorf("business hours are 24-hour times such as 09:00, not %q", c)
}
}
if t.Start != "" && t.Start == t.End {
return errors.New("business hours start and end at the same time")
}
for _, d := range t.Days {
if !slices.Contains(weekdays, d) {
return fmt.Errorf("business days are mon to sun, not %q", d)
}
}
for _, b := range t.Blackouts {
if b.From.IsZero() || !b.To.After(b.From) {
return errors.New("a blackout needs a start and a later end")
}
}
return nil
}
func (t Timing) location() (*time.Location, error) {
if t.Zone == "" {
return time.UTC, nil
}
loc, err := time.LoadLocation(t.Zone)
if err != nil {
return nil, fmt.Errorf("unknown time zone %q", t.Zone)
}
return loc, nil
}
// Hold says whether an action that changes something must wait at now, and why.
func (t Timing) Hold(now time.Time) (string, bool) {
for _, b := range t.Blackouts {
if !now.Before(b.From) && now.Before(b.To) {
if b.Reason == "" {
return "a blackout is in force", true
}
return "a blackout is in force: " + b.Reason, true
}
}
if t.Start == "" {
return "", false
}
loc, err := t.location()
if err != nil {
loc = time.UTC
}
local := now.In(loc)
if len(t.Days) > 0 && !slices.Contains(t.Days, weekdays[local.Weekday()]) {
return "outside business days", true
}
at := local.Format(clock)
inside := at >= t.Start && at < t.End
if t.Start > t.End {
inside = at >= t.Start || at < t.End
}
if !inside {
return "outside business hours", true
}
return "", false
}
// normalised lowercases the days so they compare, and gives a nil list a value
// that encodes as an array.
func (t Timing) normalised() Timing {
days := make([]string, len(t.Days))
for i, d := range t.Days {
days[i] = strings.ToLower(d)
}
t.Days = days
if t.Blackouts == nil {
t.Blackouts = []Blackout{}
}
return t
}
// Timing returns when the organisation lets changing actions run unasked.
func (m *Module) Timing(ctx context.Context) (Timing, error) {
set, err := m.Settings(ctx)
if err != nil {
return Timing{}, err
}
return set.Timing, nil
}
// Hold says whether an action that changes something must wait now, and why.
func (m *Module) Hold(ctx context.Context, now time.Time) (string, bool, error) {
t, err := m.Timing(ctx)
if err != nil {
return "", false, err
}
reason, held := t.Hold(now)
return reason, held, nil
}
// ActionBudgets returns how many actions one run, and the organisation in a
// day, may take.
func (m *Module) ActionBudgets(ctx context.Context) (perRun, perDay int, err error) {
set, err := m.Settings(ctx)
if err != nil {
return 0, 0, err
}
return set.ActionsPerRun, set.ActionsPerDay, nil
}
+49
View File
@@ -0,0 +1,49 @@
package governance
import (
"testing"
"time"
)
// TestTimingHoldsChangingActionsOutsideTheSchedule guards the schedule's
// reading: business hours in the organisation's zone, an overnight window, and
// a blackout that holds inside business hours.
func TestTimingHoldsChangingActionsOutsideTheSchedule(t *testing.T) {
at := func(s string) time.Time {
v, err := time.Parse(time.RFC3339, s)
if err != nil {
t.Fatal(err)
}
return v
}
office := Timing{Start: "09:00", End: "17:00", Days: []string{"mon", "tue", "wed", "thu", "fri"}}
night := Timing{Start: "22:00", End: "06:00"}
release := Timing{Blackouts: []Blackout{{From: at("2026-11-17T00:00:00Z"), To: at("2026-11-18T00:00:00Z"), Reason: "release"}}}
zoned := Timing{Zone: "UTC", Start: "09:00", End: "17:00"}
tests := []struct {
name string
t Timing
now string
held bool
}{
{"nothing set", Timing{}, "2026-11-17T03:00:00Z", false},
{"inside business hours", office, "2026-11-17T10:00:00Z", false},
{"before business hours", office, "2026-11-17T08:59:00Z", true},
{"at close", office, "2026-11-17T17:00:00Z", true},
{"a weekend", office, "2026-11-15T10:00:00Z", true},
{"overnight window, late", night, "2026-11-17T23:00:00Z", false},
{"overnight window, early", night, "2026-11-17T05:00:00Z", false},
{"overnight window, midday", night, "2026-11-17T12:00:00Z", true},
{"inside a blackout", release, "2026-11-17T12:00:00Z", true},
{"after a blackout", release, "2026-11-18T00:00:00Z", false},
{"zone given", zoned, "2026-11-17T18:00:00Z", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if reason, held := tt.t.Hold(at(tt.now)); held != tt.held {
t.Errorf("held = %v (%s), want %v", held, reason, tt.held)
}
})
}
}
+86
View File
@@ -0,0 +1,86 @@
package judgement
import (
"context"
"fmt"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/samcharles93/archie-core/modules/judgement/internal/store"
)
// Budgets says how many actions one run, and the organisation in a day, may
// take.
type Budgets interface {
ActionBudgets(ctx context.Context) (perRun, perDay int, err error)
}
// ActionCounts says how many changing actions were judged for a run, and in
// the day before now, not counting the attempt named key.
type ActionCounts interface {
Actions(ctx context.Context, runID uuid.UUID, key string, now time.Time) (inRun, inDay int, err error)
}
// Spend counts the changing actions the module has judged. Refused actions
// cost nothing.
type Spend struct {
store *store.Store
orgID string
}
// NewSpend returns the action counts for orgID.
func NewSpend(db *sqlx.DB, orgID string) *Spend { return &Spend{store: store.New(db), orgID: orgID} }
// Actions counts the run's actions, and the organisation's in the 24 hours
// before now, leaving out the attempt named key so a replay isn't charged twice.
func (s *Spend) Actions(ctx context.Context, runID uuid.UUID, key string, now time.Time) (inRun, inDay int, err error) {
return s.store.CountActions(ctx, s.orgID, runID, key, now.Add(-24*time.Hour))
}
// Cost holds an action that changes something at propose and wait once its run
// or the organisation's day has used its action budget. Reading is free.
type Cost struct {
Budgets Budgets
Counts ActionCounts
// Now is the clock; nil means time.Now.
Now func() time.Time
}
// Name is the guard's name in verdicts.
func (Cost) Name() string { return "cost" }
// Advisory is false.
func (Cost) Advisory() bool { return false }
// Judge returns the cost ceiling.
func (c Cost) Judge(ctx context.Context, a Action) (Verdict, error) {
if a.Effect.ReadOnly {
return Verdict{Ceiling: ActQuietly}, nil
}
perRun, perDay, err := c.Budgets.ActionBudgets(ctx)
if err != nil {
return Verdict{}, fmt.Errorf("read budgets: %w", err)
}
now := time.Now
if c.Now != nil {
now = c.Now
}
run := runFrom(ctx)
inRun, inDay, err := c.Counts.Actions(ctx, run.RunID, run.Key, now())
if err != nil {
return Verdict{}, fmt.Errorf("count actions: %w", err)
}
var findings []Finding
if inRun >= perRun {
findings = append(findings, Finding{Text: fmt.Sprintf("this run has used its budget of %d actions", perRun)})
}
if inDay >= perDay {
findings = append(findings, Finding{Text: fmt.Sprintf("the organisation has used its budget of %d actions for the day", perDay)})
}
if len(findings) > 0 {
return Verdict{Ceiling: ProposeAndWait, Findings: findings}, nil
}
return Verdict{Ceiling: ActQuietly}, nil
}
+126
View File
@@ -0,0 +1,126 @@
package judgement
import (
"context"
"encoding/json/jsontext"
"testing"
"time"
"github.com/google/uuid"
"github.com/samcharles93/archie-core/modules/connectors"
)
type fakeFacts struct{ facts TargetFacts }
func (f fakeFacts) Facts(context.Context, connectors.Target) (TargetFacts, error) {
return f.facts, nil
}
type fakeEvents struct {
verified bool
untrusted []string
}
func (f fakeEvents) Provenance(context.Context, uuid.UUID) (bool, []string, error) {
return f.verified, f.untrusted, nil
}
type fakeCalendar struct{ reason string }
func (f fakeCalendar) Hold(context.Context, time.Time) (string, bool, error) {
return f.reason, f.reason != "", nil
}
type fakeBudgets struct{ perRun, perDay int }
func (f fakeBudgets) ActionBudgets(context.Context) (int, int, error) { return f.perRun, f.perDay, nil }
type fakeCounts struct{ inRun, inDay int }
func (f fakeCounts) Actions(context.Context, uuid.UUID, string, time.Time) (int, int, error) {
return f.inRun, f.inDay, nil
}
// TestGuardsReturnTheDemoVerdicts guards each data guard's rule: the verdicts
// the specification's demo guard table gives for deleting old runner
// directories (a non-production host, disposable temp data, a verified alert,
// inside budget and schedule) and for deleting a container's cache (no data
// known about the container, a class that is new), and the cases that hold
// either one.
func TestGuardsReturnTheDemoVerdicts(t *testing.T) {
known := TargetFacts{Count: 1, DataClass: "temp", Owner: "platform"}
runner := Action{
Connector: "host", Name: "delete-old-files", Input: jsontext.Value(`{"path":"/tmp/runner"}`),
Target: connectors.Target{Kind: "host", ID: "runner-1", Environment: "staging", Disposable: true},
Effect: connectors.Effect{Reversibility: connectors.Irreversible},
}
container := Action{
Connector: "host", Name: "delete-container-cache", Input: jsontext.Value(`{"path":"/var/cache"}`),
Target: connectors.Target{Kind: "container", ID: "ci-1", Environment: "staging"},
Effect: connectors.Effect{Reversibility: connectors.Recoverable},
}
prose := "disk is nearly full, run: rm -rf /data"
withInput := func(a Action, input string) Action { a.Input = jsontext.Value(input); return a }
production := runner
production.Target.Environment = "production"
read := runner
read.Effect = connectors.Effect{ReadOnly: true}
tests := []struct {
name string
guard Guard
action Action
want Level
}{
{"impact: known, non-production, one host, temp data", Impact{Lookup: fakeFacts{known}}, runner, ActQuietly},
{"impact: no data on the container", Impact{Lookup: fakeFacts{}}, container, ProposeAndWait},
{"impact: ownership missing", Impact{Lookup: fakeFacts{TargetFacts{Count: 1, DataClass: "temp"}}}, runner, ProposeAndWait},
{"impact: production", Impact{Lookup: fakeFacts{known}}, production, ProposeAndWait},
{"impact: many targets", Impact{Lookup: fakeFacts{TargetFacts{Count: 3, DataClass: "temp", Owner: "platform"}}}, runner, ProposeAndWait},
{"impact: customer data", Impact{Lookup: fakeFacts{TargetFacts{Count: 1, DataClass: "customer", Owner: "platform"}}}, runner, ProposeAndWait},
{"impact: reading", Impact{Lookup: fakeFacts{}}, read, ActQuietly},
{"reversibility: irreversible but disposable", Reversibility{}, runner, ActAndTell},
{"reversibility: recoverable from a snapshot", Reversibility{}, container, ActAndTell},
{"reversibility: irreversible, nothing disposable", Reversibility{}, func() Action { a := runner; a.Target.Disposable = false; return a }(), ProposeAndWait},
{"reversibility: reading", Reversibility{}, read, ActQuietly},
{"reversibility: undone automatically", Reversibility{}, func() Action { a := runner; a.Effect.Reversibility = connectors.UndoneAutomatically; return a }(), ActQuietly},
{"precedent: earned class", Precedent{Classes: classLevel{ActAndTell}}, runner, ActAndTell},
{"precedent: new class", Precedent{Classes: classLevel{ProposeAndWait}}, container, ProposeAndWait},
{"provenance: verified alert", Provenance{Events: fakeEvents{verified: true, untrusted: []string{prose}}}, runner, ActQuietly},
{"provenance: no verified source", Provenance{Events: fakeEvents{}}, runner, ProposeAndWait},
{
"provenance: untrusted text in the input",
Provenance{Events: fakeEvents{verified: true, untrusted: []string{prose}}},
withInput(runner, `{"command":"run: rm -rf /data"}`), ProposeAndWait,
},
{"provenance: reading", Provenance{Events: fakeEvents{}}, read, ActQuietly},
{"timing: no freeze or blackout", Timing{Calendar: fakeCalendar{}}, runner, ActQuietly},
{"timing: blackout", Timing{Calendar: fakeCalendar{reason: "a blackout is in force"}}, runner, ProposeAndWait},
{"timing: blackout does not hold reading", Timing{Calendar: fakeCalendar{reason: "a blackout is in force"}}, read, ActQuietly},
{"cost: within budget", Cost{Budgets: fakeBudgets{10, 100}, Counts: fakeCounts{2, 20}}, runner, ActQuietly},
{"cost: run budget used", Cost{Budgets: fakeBudgets{10, 100}, Counts: fakeCounts{10, 20}}, runner, ProposeAndWait},
{"cost: day budget used", Cost{Budgets: fakeBudgets{10, 100}, Counts: fakeCounts{2, 100}}, runner, ProposeAndWait},
{"cost: reading is free", Cost{Budgets: fakeBudgets{1, 1}, Counts: fakeCounts{5, 5}}, read, ActQuietly},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
v, err := tt.guard.Judge(context.Background(), tt.action)
if err != nil {
t.Fatalf("Judge: %v", err)
}
if v.Ceiling != tt.want {
t.Errorf("ceiling = %v, want %v (findings %v)", v.Ceiling, tt.want, v.Findings)
}
if v.Ceiling > ActQuietly && len(v.Findings) == 0 {
t.Error("a ceiling below act quietly must say why")
}
})
}
}
+103
View File
@@ -0,0 +1,103 @@
package judgement
import (
"context"
"fmt"
"slices"
"github.com/samcharles93/archie-core/modules/connectors"
)
// TargetFacts is what a lookup knows about an action's target. A zero field
// is a fact nobody has supplied.
type TargetFacts struct {
// Count is how many things the action reaches.
Count int
// DataClass names what the target holds, such as "temp" or "customer".
DataClass string
// Owner is who answers for the target.
Owner string
}
// TargetLookup supplies the facts the target's own declaration lacks.
type TargetLookup interface {
Facts(ctx context.Context, t connectors.Target) (TargetFacts, error)
}
// NoTargetFacts knows nothing about any target, so Impact holds every changing
// action until a connector lookup supplies the data.
type NoTargetFacts struct{}
// Facts returns no facts.
func (NoTargetFacts) Facts(context.Context, connectors.Target) (TargetFacts, error) {
return TargetFacts{}, nil
}
const (
environmentProduction = "production"
dataTemp = "temp"
dataCache = "cache"
dataNone = "none"
)
// lowRiskData are the data classes whose loss costs nothing that can't be
// regenerated.
var lowRiskData = []string{dataTemp, dataCache, dataNone}
// Impact sets a ceiling from what breaks if the action goes wrong: the
// environment, how many targets it reaches, what data they hold and who owns
// them. A datum nobody supplied holds the action at propose and wait.
type Impact struct {
Lookup TargetLookup
}
// Name is the guard's name in verdicts.
func (Impact) Name() string { return "impact" }
// Advisory is false.
func (Impact) Advisory() bool { return false }
// Judge returns the impact ceiling. Reading breaks nothing.
func (i Impact) Judge(ctx context.Context, a Action) (Verdict, error) {
if a.Effect.ReadOnly {
return Verdict{Ceiling: ActQuietly}, nil
}
facts, err := i.Lookup.Facts(ctx, a.Target)
if err != nil {
return Verdict{}, fmt.Errorf("look up target facts: %w", err)
}
if missing := missingImpactData(a.Target, facts); len(missing) > 0 {
v := Verdict{Ceiling: ProposeAndWait, BlindSpots: missing}
for _, m := range missing {
v.Findings = append(v.Findings, Finding{Text: "no " + m + " is known for the target"})
}
return v, nil
}
switch {
case a.Target.Environment == environmentProduction:
return Verdict{Ceiling: ProposeAndWait, Findings: []Finding{{Text: "the target is in production"}}}, nil
case facts.Count > 1:
return Verdict{Ceiling: ProposeAndWait, Findings: []Finding{{Text: fmt.Sprintf("the action reaches %d targets", facts.Count)}}}, nil
case !slices.Contains(lowRiskData, facts.DataClass):
return Verdict{Ceiling: ProposeAndWait, Findings: []Finding{{Text: "the target holds " + facts.DataClass + " data"}}}, nil
}
return Verdict{Ceiling: ActQuietly}, nil
}
// missingImpactData names what Impact needs and doesn't have.
func missingImpactData(t connectors.Target, f TargetFacts) []string {
var missing []string
if t.Environment == "" {
missing = append(missing, "environment")
}
if f.Count < 1 {
missing = append(missing, "target count")
}
if f.DataClass == "" {
missing = append(missing, "data class")
}
if f.Owner == "" {
missing = append(missing, "owner")
}
return missing
}
+21
View File
@@ -69,3 +69,24 @@ func (s *Store) ForRun(ctx context.Context, orgID string, runID uuid.UUID) ([]De
} }
return out, nil return out, nil
} }
// CountActions counts the decisions for actions that change something: those
// of a run, and every one made since the cutoff. It leaves out the attempt
// named key and anything a hard rule refused. Whether an action only reads is
// in the decision body, as the encoding of connectors.Effect.
func (s *Store) CountActions(ctx context.Context, orgID string, runID uuid.UUID, key string, since time.Time) (inRun, inDay int, err error) {
var n struct {
Run int `db:"in_run"`
Day int `db:"in_day"`
}
err = s.db.GetContext(ctx, &n, `
SELECT count(*) FILTER (WHERE run_id = $2) AS in_run,
count(*) FILTER (WHERE created_at >= $4) AS in_day
FROM judgement.decisions
WHERE org_id = $1 AND key <> $3 AND level <> 'never'
AND COALESCE((body->'action'->'effect'->>'ReadOnly')::boolean, false) = false`, orgID, runID, key, since)
if err != nil {
return 0, 0, fmt.Errorf("count actions: %w", err)
}
return n.Run, n.Day, nil
}
+99
View File
@@ -0,0 +1,99 @@
package judgement
import (
"context"
"encoding/json/jsontext"
json "encoding/json/v2"
"fmt"
"strings"
"github.com/google/uuid"
)
// Events says where a run came from. The events module implements it, so the
// guard never reads another module's tables.
type Events interface {
// Provenance reports whether a verified source started the run, and the
// free text that source's event carried. A run no event started is not
// verified.
Provenance(ctx context.Context, runID uuid.UUID) (verified bool, untrusted []string, err error)
}
// Provenance holds a changing action when nobody verified who asked, or when
// text a stranger wrote has found its way into the action's input.
type Provenance struct {
Events Events
}
// Name is the guard's name in verdicts.
func (Provenance) Name() string { return "provenance" }
// Advisory is false.
func (Provenance) Advisory() bool { return false }
// minOverlap is the shortest input text worth comparing with untrusted text.
const minOverlap = 8
// Judge returns the provenance ceiling. Reading changes nothing a stranger
// could steer, so it passes.
func (p Provenance) Judge(ctx context.Context, a Action) (Verdict, error) {
if a.Effect.ReadOnly {
return Verdict{Ceiling: ActQuietly}, nil
}
verified, untrusted, err := p.Events.Provenance(ctx, runFrom(ctx).RunID)
if err != nil {
return Verdict{}, fmt.Errorf("read run provenance: %w", err)
}
var findings []Finding
if !verified {
findings = append(findings, Finding{Text: "no verified source started this run"})
}
if text, ok := carriesUntrusted(a.Input, untrusted); ok {
findings = append(findings, Finding{Text: "the action's input carries untrusted text from the event", Evidence: text})
}
if len(findings) > 0 {
return Verdict{Ceiling: ProposeAndWait, Findings: findings}, nil
}
return Verdict{Ceiling: ActQuietly}, nil
}
// carriesUntrusted reports whether a phrase in input (text with a space in it,
// so not an identifier or a path) overlaps text the event carried, and returns
// that phrase.
func carriesUntrusted(input jsontext.Value, untrusted []string) (string, bool) {
if len(untrusted) == 0 || len(input) == 0 {
return "", false
}
var v any
if err := json.Unmarshal(input, &v); err != nil {
return string(input), true
}
var found string
walkStrings(v, func(s string) {
if found != "" || len(s) < minOverlap || !strings.ContainsAny(s, " \t\n") {
return
}
for _, u := range untrusted {
if strings.Contains(s, u) || strings.Contains(u, s) {
found = s
return
}
}
})
return found, found != ""
}
func walkStrings(v any, fn func(string)) {
switch x := v.(type) {
case string:
fn(x)
case []any:
for _, e := range x {
walkStrings(e, fn)
}
case map[string]any:
for _, e := range x {
walkStrings(e, fn)
}
}
}
+46
View File
@@ -0,0 +1,46 @@
package judgement
import (
"context"
"fmt"
"time"
)
// Calendar says whether the organisation's schedule holds changing actions
// now: business hours and blackout windows.
type Calendar interface {
Hold(ctx context.Context, now time.Time) (reason string, held bool, err error)
}
// Timing holds every action that changes something at propose and wait outside
// business hours and inside a blackout. Reading is never held.
type Timing struct {
Calendar Calendar
// Now is the clock; nil means time.Now.
Now func() time.Time
}
// Name is the guard's name in verdicts.
func (Timing) Name() string { return "timing" }
// Advisory is false.
func (Timing) Advisory() bool { return false }
// Judge returns the timing ceiling.
func (t Timing) Judge(ctx context.Context, a Action) (Verdict, error) {
if a.Effect.ReadOnly {
return Verdict{Ceiling: ActQuietly}, nil
}
now := time.Now
if t.Now != nil {
now = t.Now
}
reason, held, err := t.Calendar.Hold(ctx, now())
if err != nil {
return Verdict{}, fmt.Errorf("read schedule: %w", err)
}
if held {
return Verdict{Ceiling: ProposeAndWait, Findings: []Finding{{Text: reason}}}, nil
}
return Verdict{Ceiling: ActQuietly}, nil
}
+104 -1
View File
@@ -10,8 +10,9 @@ import { Section } from "@/components/ui/section";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select"; import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import { SettingRow } from "@/components/ui/setting-row"; import { SettingRow } from "@/components/ui/setting-row";
import { Spinner } from "@/components/ui/spinner"; import { Spinner } from "@/components/ui/spinner";
import { Input } from "@/components/ui/input";
import { Switch } from "@/components/ui/switch"; import { Switch } from "@/components/ui/switch";
import { getPeople, getSettings, saveSettings, Unauthorized, type Person } from "./api"; import { getPeople, getSettings, saveSettings, Unauthorized, type Blackout, type Person } from "./api";
/** /**
* Organisation settings: what Archie does when nobody has decided otherwise. * Organisation settings: what Archie does when nobody has decided otherwise.
@@ -24,6 +25,20 @@ const raiseAfter = ref(3);
const frozen = ref(false); const frozen = ref(false);
const threshold = ref(5); const threshold = ref(5);
const attempts = ref(20); const attempts = ref(20);
const actionsPerRun = ref(10);
const actionsPerDay = ref(100);
const zone = ref("");
const hoursStart = ref("");
const hoursEnd = ref("");
const days = ref<string[]>([]);
const weekdays = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
/** A blackout as the form edits it: local date-times, which the API takes as instants. */
interface BlackoutRow {
from: string;
to: string;
reason: string;
}
const blackouts = ref<BlackoutRow[]>([]);
const people = ref<Person[]>([]); const people = ref<Person[]>([]);
const none = "none"; const none = "none";
const owner = ref(none); const owner = ref(none);
@@ -45,6 +60,13 @@ async function load() {
frozen.value = set.frozen; frozen.value = set.frozen;
threshold.value = set.recurrence_threshold; threshold.value = set.recurrence_threshold;
attempts.value = set.attempts_per_run; attempts.value = set.attempts_per_run;
actionsPerRun.value = set.actions_per_run;
actionsPerDay.value = set.actions_per_day;
zone.value = set.timing.zone;
hoursStart.value = set.timing.start;
hoursEnd.value = set.timing.end;
days.value = set.timing.days;
blackouts.value = set.timing.blackouts.map((b) => ({ from: toLocal(b.from), to: toLocal(b.to), reason: b.reason }));
owner.value = set.default_owner || none; owner.value = set.default_owner || none;
escalation.value = set.escalation; escalation.value = set.escalation;
} catch (err) { } catch (err) {
@@ -67,6 +89,15 @@ async function save() {
attempts_per_run: attempts.value, attempts_per_run: attempts.value,
default_owner: owner.value === none ? "" : owner.value, default_owner: owner.value === none ? "" : owner.value,
escalation: escalation.value, escalation: escalation.value,
actions_per_run: actionsPerRun.value,
actions_per_day: actionsPerDay.value,
timing: {
zone: zone.value,
start: hoursStart.value,
end: hoursEnd.value,
days: days.value,
blackouts: blackouts.value.map((b): Blackout => ({ from: toInstant(b.from), to: toInstant(b.to), reason: b.reason })),
},
}); });
saved.value = "Saved."; saved.value = "Saved.";
} catch (err) { } catch (err) {
@@ -76,6 +107,22 @@ async function save() {
} }
} }
/** An instant as the local "2026-01-02T15:04" a datetime-local input takes. */
function toLocal(instant: string): string {
const d = new Date(instant);
const pad = (n: number) => String(n).padStart(2, "0");
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}`;
}
function toInstant(local: string): string {
const d = new Date(local);
return Number.isNaN(d.getTime()) ? "" : d.toISOString();
}
function toggleDay(day: string) {
days.value = days.value.includes(day) ? days.value.filter((d) => d !== day) : [...days.value, day];
}
const addable = () => people.value.filter((p) => !escalation.value.includes(p.id)); const addable = () => people.value.filter((p) => !escalation.value.includes(p.id));
const nameOf = (id: string) => people.value.find((p) => p.id === id)?.name ?? id; const nameOf = (id: string) => people.value.find((p) => p.id === id)?.name ?? id;
@@ -142,6 +189,62 @@ onBeforeUnmount(() => controller.abort());
</NumberField> </NumberField>
</SettingRow> </SettingRow>
<p class="text-caption text-muted-foreground">Steps an agent may take in one run before it stops.</p> <p class="text-caption text-muted-foreground">Steps an agent may take in one run before it stops.</p>
<SettingRow label="Actions per run" for="actions-per-run">
<NumberField v-model="actionsPerRun" :min="1" :max="10000" class="w-32">
<NumberFieldContent>
<NumberFieldDecrement />
<NumberFieldInput id="actions-per-run" class="font-mono" />
<NumberFieldIncrement />
</NumberFieldContent>
</NumberField>
</SettingRow>
<SettingRow label="Actions per day" for="actions-per-day">
<NumberField v-model="actionsPerDay" :min="1" :max="10000" class="w-32">
<NumberFieldContent>
<NumberFieldDecrement />
<NumberFieldInput id="actions-per-day" class="font-mono" />
<NumberFieldIncrement />
</NumberFieldContent>
</NumberField>
</SettingRow>
<p class="text-caption text-muted-foreground">
Actions that change something, per run and over any 24 hours. Past either, the next one waits for approval.
</p>
<SettingRow label="Business hours" for="hours-start">
<div class="flex items-center gap-2">
<Input id="hours-start" v-model="hoursStart" type="time" class="w-32" aria-label="Business hours start" />
<Input v-model="hoursEnd" type="time" class="w-32" aria-label="Business hours end" />
<Input v-model="zone" class="w-48" placeholder="Zone, such as Australia/Sydney" aria-label="Time zone" />
</div>
</SettingRow>
<SettingRow label="Business days">
<div class="flex gap-1">
<Button
v-for="day in weekdays"
:key="day"
:variant="days.includes(day) ? 'default' : 'outline'"
size="xs"
:aria-pressed="days.includes(day)"
@click="toggleDay(day)"
>
{{ day }}
</Button>
</div>
</SettingRow>
<p class="text-caption text-muted-foreground">
Outside these, actions that change something wait for approval. Leave the times empty for every hour, and no days for every day.
</p>
<SettingRow label="Blackouts">
<div class="flex flex-col gap-2">
<div v-for="(b, index) in blackouts" :key="index" class="flex items-center gap-2">
<Input v-model="b.from" type="datetime-local" class="w-56" aria-label="Blackout start" />
<Input v-model="b.to" type="datetime-local" class="w-56" aria-label="Blackout end" />
<Input v-model="b.reason" class="w-48" placeholder="Reason" aria-label="Blackout reason" />
<Button variant="ghost" size="xs" @click="blackouts.splice(index, 1)">Remove</Button>
</div>
<Button variant="outline" size="xs" class="self-start" @click="blackouts.push({ from: '', to: '', reason: '' })">Add blackout</Button>
</div>
</SettingRow>
<SettingRow label="Default owner" for="default-owner"> <SettingRow label="Default owner" for="default-owner">
<Select v-model="owner"> <Select v-model="owner">
<SelectTrigger id="default-owner" class="w-64"><SelectValue /></SelectTrigger> <SelectTrigger id="default-owner" class="w-64"><SelectValue /></SelectTrigger>
+24
View File
@@ -154,6 +154,30 @@ export interface Settings {
default_owner: string; default_owner: string;
/** Person ids, in the order an unanswered request moves through them. */ /** Person ids, in the order an unanswered request moves through them. */
escalation: string[]; escalation: string[];
/** When actions that change something may run without asking. */
timing: Timing;
/** Changing actions one run may take before the next waits for approval. */
actions_per_run: number;
/** Changing actions the organisation may take in a day before the next waits. */
actions_per_day: number;
}
export interface Timing {
/** An IANA zone such as "Australia/Sydney"; empty is UTC. */
zone: string;
/** "09:00"; empty start and end mean every hour. */
start: string;
end: string;
/** "mon" to "sun"; empty means every day. */
days: string[];
blackouts: Blackout[];
}
export interface Blackout {
/** RFC 3339 instants. */
from: string;
to: string;
reason: string;
} }
export const getSettings = (signal?: AbortSignal) => get<Settings>("/api/settings", signal); export const getSettings = (signal?: AbortSignal) => get<Settings>("/api/settings", signal);