feat(judgement,approvals,ui): action classes are records with a level, history and reset; the precedent guard reads the class level (#2003)

This commit is contained in:
sam committed 2026-11-16 04:35:12 +11:00
1 parent 5712c9c4e6
commit a91df7ec1f
15 files changed
+900 -16

No files matched your search

+23 -7
View File
@@ -15,6 +15,7 @@ import (
"sync"
"time"
"github.com/jmoiron/sqlx"
"github.com/samcharles93/ai-sdk/runtime"
"github.com/samcharles93/archie-core/internal/buildinfo"
@@ -85,12 +86,12 @@ func Run(ctx context.Context, configPath string) error {
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
// from the request.
judge := judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, nil,
[]judgement.Guard{judgement.Reversibility{}, judgement.Precedent{}})
judge, classes := newJudgement(db, log, conns)
// An approval request is carried by deliveries, and its answer wakes the run
// that is waiting on it.
allow := approvals.NewModule(db, log.With("module", "approvals"), orgID, tell, engine)
allow.Routes(mux, guard)
classes.Routes(mux, guard, allow)
engine.Register("investigate", runs.Investigate(settings, conns, judge, allow, tell)) //nolint:contextcheck // see above
// An answer a channel delivers is an event, and settles its request.
@@ -101,17 +102,32 @@ func Run(ctx context.Context, configPath string) error {
ctx, stop := context.WithCancel(ctx)
defer stop()
var workers sync.WaitGroup
workers.Go(func() { engine.Work(ctx) })
workers.Go(func() { hear.Work(ctx) })
workers.Go(func() { tell.Work(ctx) })
wait := work(ctx, engine.Work, hear.Work, tell.Work)
err = serve(ctx, log, cfg.Listen, mux)
stop()
workers.Wait()
wait()
return err
}
// work runs each loop until ctx ends and returns a function that waits for
// them all.
func work(ctx context.Context, loops ...func(context.Context)) func() {
var workers sync.WaitGroup
for _, loop := range loops {
workers.Go(func() { loop(ctx) })
}
return workers.Wait
}
// newJudgement returns the judgement module and the action classes its
// precedent guard reads.
func newJudgement(db *sqlx.DB, log *slog.Logger, conns judgement.Tools) (*judgement.Module, *judgement.Classes) {
classes := judgement.NewClasses(db, log.With("module", "judgement"), orgID)
return judgement.NewModule(db, log.With("module", "judgement"), orgID, conns, nil,
[]judgement.Guard{judgement.Reversibility{}, judgement.Precedent{Classes: classes}}), classes
}
// orgID is the one organisation until hosting is multi-tenant.
const orgID = "default"
@@ -0,0 +1,36 @@
-- +goose Up
-- An action class is what earned autonomy belongs to: one connector's action on
-- one kind of target in one environment. A class is made the first time an
-- action of it is judged, at the level its kind of action starts at, and its
-- decisions stay in judgement.decisions under the same four names. A target
-- that moves environment is a different class, which starts as any new one.
CREATE TABLE judgement.classes (
id uuid PRIMARY KEY,
org_id text NOT NULL,
connector text NOT NULL,
action text NOT NULL,
target_kind text NOT NULL,
environment text NOT NULL,
read_only boolean NOT NULL,
level text NOT NULL CHECK (level IN ('act_quietly', 'act_and_tell', 'propose_and_wait', 'escalate', 'never')),
created_at timestamptz NOT NULL DEFAULT now(),
reset_at timestamptz,
UNIQUE (org_id, connector, action, target_kind, environment)
);
-- A reset returns a class to its default and keeps what led there.
CREATE TABLE judgement.class_resets (
id uuid PRIMARY KEY,
org_id text NOT NULL,
class_id uuid NOT NULL REFERENCES judgement.classes (id),
from_level text NOT NULL,
to_level text NOT NULL,
by text NOT NULL,
at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX class_resets_by_class ON judgement.class_resets (class_id, at);
-- +goose Down
DROP TABLE judgement.class_resets;
DROP TABLE judgement.classes;
+21
View File
@@ -262,6 +262,27 @@ func (m *Module) ForRun(ctx context.Context, runID uuid.UUID) ([]Request, error)
return out, nil
}
// Outcomes says what became of the requests made for the decisions in ids,
// for the history of the action class they belong to.
func (m *Module) Outcomes(ctx context.Context, ids []uuid.UUID) (map[uuid.UUID]judgement.Outcome, error) {
rows, err := m.store.ByDecisions(ctx, m.orgID, ids)
if err != nil {
return nil, err
}
out := make(map[uuid.UUID]judgement.Outcome, len(rows))
for _, row := range rows {
o := judgement.Outcome{State: row.State}
if row.AnsweredBy.Valid {
o.By = row.AnsweredBy.String
}
if row.AnsweredAt.Valid {
o.At = row.AnsweredAt.Time
}
out[row.DecisionID] = o
}
return out, nil
}
// Routes adds the approvals API to mux behind guard.
func (m *Module) Routes(mux *http.ServeMux, guard func(http.Handler) http.Handler) {
mux.Handle("GET /api/approvals", guard(http.HandlerFunc(m.list)))
+18
View File
@@ -136,5 +136,23 @@ func (s *Store) ForRun(ctx context.Context, orgID string, runID uuid.UUID) ([]Re
return out, nil
}
// ByDecisions returns the requests made for the decisions in ids.
func (s *Store) ByDecisions(ctx context.Context, orgID string, ids []uuid.UUID) ([]Request, error) {
if len(ids) == 0 {
return nil, nil
}
query, args, err := sqlx.In(`
SELECT `+requestColumns+` FROM approvals.requests
WHERE org_id = ? AND decision_id IN (?) ORDER BY created_at`, orgID, ids)
if err != nil {
return nil, fmt.Errorf("list requests by decision: %w", err)
}
var out []Request
if err := s.db.SelectContext(ctx, &out, s.db.Rebind(query), args...); err != nil {
return nil, fmt.Errorf("list requests by decision: %w", err)
}
return out, nil
}
// ErrNotFound means no request has that id or key.
var ErrNotFound = errors.New("no such approval request")
+302
View File
@@ -0,0 +1,302 @@
package judgement
import (
"context"
json "encoding/json/v2"
"errors"
"fmt"
"log/slog"
"net/http"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/samcharles93/archie-core/internal/platform/httpjson"
"github.com/samcharles93/archie-core/modules/judgement/internal/store"
)
// historyLimit bounds the decisions one class's history returns.
const historyLimit = 100
// ErrNoClass means no action class has that id.
var ErrNoClass = store.ErrNoClass
// DefaultLevel is the level a class starts at, and returns to on a reset:
// reading starts at act quietly, everything else at propose and wait.
func DefaultLevel(readOnly bool) Level {
if readOnly {
return ActQuietly
}
return ProposeAndWait
}
// Outcome is what became of a decision's request for approval.
type Outcome struct {
State string
By string
At time.Time
}
// Outcomes says what became of decisions that were held for approval. It is
// the approvals module's to answer, so a class's history can show it.
type Outcomes interface {
Outcomes(ctx context.Context, ids []uuid.UUID) (map[uuid.UUID]Outcome, error)
}
// Classes owns one organisation's action classes: the level each stands at and
// the history behind it.
type Classes struct {
orgID string
store *store.Store
log *slog.Logger
now func() time.Time
}
// NewClasses returns the action classes of orgID.
func NewClasses(db *sqlx.DB, log *slog.Logger, orgID string) *Classes {
return &Classes{orgID: orgID, store: store.New(db), log: log, now: time.Now}
}
// Level returns the level c stands at, making the class at its default if this
// is the first action of it. readOnly is the action's own declaration and is
// kept with the class, so a reset knows what its default is.
func (c *Classes) Level(ctx context.Context, class Class, readOnly bool) (Level, error) {
row, err := c.store.EnsureClass(ctx, store.Class{
ID: uuid.New(), OrgID: c.orgID, Connector: class.Connector, Action: class.Action,
TargetKind: class.TargetKind, Environment: class.Environment,
ReadOnly: readOnly, Level: DefaultLevel(readOnly).String(),
})
if err != nil {
return 0, err
}
return parseLevel(row.Level)
}
func parseLevel(s string) (Level, error) {
var l Level
if err := l.UnmarshalText([]byte(s)); err != nil {
return 0, err
}
return l, nil
}
// ClassView is an action class as the API lists it.
type ClassView struct {
ID uuid.UUID `json:"id"`
Connector string `json:"connector"`
Action string `json:"action"`
TargetKind string `json:"target_kind"`
Environment string `json:"environment"`
Level Level `json:"level"`
Default Level `json:"default"`
Decisions int `json:"decisions"`
LastDecidedAt *time.Time `json:"last_decided_at,omitzero"`
ResetAt *time.Time `json:"reset_at,omitzero"`
}
// HistoryEntry is one decision in a class's history, with what became of its
// request for approval.
type HistoryEntry struct {
DecisionID uuid.UUID `json:"decision_id"`
RunID uuid.UUID `json:"run_id"`
Target string `json:"target"`
Level Level `json:"level"`
Refused string `json:"refused_by,omitzero"`
// Approval is the state of the request for approval: pending, approved,
// denied or expired. It is empty when none was asked.
Approval string `json:"approval,omitzero"`
AnsweredBy string `json:"answered_by,omitzero"`
At time.Time `json:"at"`
}
// ResetView is one return of a class to its default.
type ResetView struct {
From Level `json:"from"`
To Level `json:"to"`
By string `json:"by"`
At time.Time `json:"at"`
}
// ClassDetail is a class with its history, newest first.
type ClassDetail struct {
ClassView
History []HistoryEntry `json:"history"`
Resets []ResetView `json:"resets"`
}
// List returns every class, most recently decided first.
func (c *Classes) List(ctx context.Context) ([]ClassView, error) {
rows, err := c.store.Classes(ctx, c.orgID)
if err != nil {
return nil, err
}
out := make([]ClassView, 0, len(rows))
for _, r := range rows {
v, err := viewOf(r.Class)
if err != nil {
return nil, err
}
v.Decisions = r.Decisions
if r.LastAt.Valid {
v.LastDecidedAt = &r.LastAt.Time
}
out = append(out, v)
}
return out, nil
}
func viewOf(r store.Class) (ClassView, error) {
level, err := parseLevel(r.Level)
if err != nil {
return ClassView{}, fmt.Errorf("class %s: %w", r.ID, err)
}
v := ClassView{
ID: r.ID, Connector: r.Connector, Action: r.Action, TargetKind: r.TargetKind,
Environment: r.Environment, Level: level, Default: DefaultLevel(r.ReadOnly),
}
if r.ResetAt.Valid {
v.ResetAt = &r.ResetAt.Time
}
return v, nil
}
// Detail returns one class with its newest decisions and resets. The approval
// outcomes come from outcomes.
func (c *Classes) Detail(ctx context.Context, id uuid.UUID, outcomes Outcomes) (ClassDetail, error) {
row, err := c.store.ClassByID(ctx, c.orgID, id)
if err != nil {
return ClassDetail{}, err
}
view, err := viewOf(row)
if err != nil {
return ClassDetail{}, err
}
decisions, err := c.store.ClassDecisions(ctx, row, historyLimit)
if err != nil {
return ClassDetail{}, err
}
resets, err := c.store.ClassResets(ctx, id)
if err != nil {
return ClassDetail{}, err
}
ids := make([]uuid.UUID, len(decisions))
for i, d := range decisions {
ids[i] = d.ID
}
got, err := outcomes.Outcomes(ctx, ids)
if err != nil {
return ClassDetail{}, err
}
detail := ClassDetail{ClassView: view, History: make([]HistoryEntry, 0, len(decisions)), Resets: make([]ResetView, 0, len(resets))}
for _, d := range decisions {
var body Decision
if err := json.Unmarshal(d.Body, &body); err != nil {
return ClassDetail{}, fmt.Errorf("decision %s: %w", d.ID, err)
}
level, err := parseLevel(d.Level)
if err != nil {
return ClassDetail{}, fmt.Errorf("decision %s: %w", d.ID, err)
}
o := got[d.ID]
detail.History = append(detail.History, HistoryEntry{
DecisionID: d.ID, RunID: d.RunID, Target: body.Action.Target.ID, Level: level,
Refused: body.RefusedBy, Approval: o.State, AnsweredBy: o.By, At: d.CreatedAt,
})
}
for _, r := range resets {
from, err := parseLevel(r.FromLevel)
if err != nil {
return ClassDetail{}, err
}
to, err := parseLevel(r.ToLevel)
if err != nil {
return ClassDetail{}, err
}
detail.Resets = append(detail.Resets, ResetView{From: from, To: to, By: r.By, At: r.At})
}
return detail, nil
}
// Reset returns a class to its default level. Its decisions and earlier resets
// stay.
func (c *Classes) Reset(ctx context.Context, id uuid.UUID, by string) (ClassView, error) {
row, err := c.store.ClassByID(ctx, c.orgID, id)
if err != nil {
return ClassView{}, err
}
row, err = c.store.ResetClass(ctx, c.orgID, id, DefaultLevel(row.ReadOnly).String(), by, c.now().UTC())
if err != nil {
return ClassView{}, err
}
return viewOf(row)
}
// bootstrapAdmin names the identity the bootstrap admin token stands for.
const bootstrapAdmin = "admin"
// Routes adds the action classes API to mux behind guard.
func (c *Classes) Routes(mux *http.ServeMux, guard func(http.Handler) http.Handler, outcomes Outcomes) {
mux.Handle("GET /api/classes", guard(http.HandlerFunc(c.list)))
mux.Handle("GET /api/classes/{id}", guard(c.detail(outcomes)))
mux.Handle("POST /api/classes/{id}/reset", guard(http.HandlerFunc(c.reset)))
}
func (c *Classes) list(w http.ResponseWriter, r *http.Request) {
out, err := c.List(r.Context())
if err != nil {
c.log.ErrorContext(r.Context(), "list classes", "error", err)
httpjson.Error(w, http.StatusInternalServerError, "couldn't list action classes")
return
}
httpjson.Write(w, http.StatusOK, out)
}
func (c *Classes) detail(outcomes Outcomes) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id, ok := classID(w, r)
if !ok {
return
}
out, err := c.Detail(r.Context(), id, outcomes)
if !c.found(w, r, err) {
return
}
httpjson.Write(w, http.StatusOK, out)
})
}
func (c *Classes) reset(w http.ResponseWriter, r *http.Request) {
id, ok := classID(w, r)
if !ok {
return
}
out, err := c.Reset(r.Context(), id, bootstrapAdmin)
if !c.found(w, r, err) {
return
}
httpjson.Write(w, http.StatusOK, out)
}
func classID(w http.ResponseWriter, r *http.Request) (uuid.UUID, bool) {
id, err := uuid.Parse(r.PathValue("id"))
if err != nil {
httpjson.Error(w, http.StatusBadRequest, "id is a class id")
return uuid.Nil, false
}
return id, true
}
// found writes the error response for err and reports whether there was none.
func (c *Classes) found(w http.ResponseWriter, r *http.Request, err error) bool {
switch {
case err == nil:
return true
case errors.Is(err, ErrNoClass):
httpjson.Error(w, http.StatusNotFound, "no such action class")
default:
c.log.ErrorContext(r.Context(), "action class", "path", r.URL.Path, "error", err)
httpjson.Error(w, http.StatusInternalServerError, "couldn't read the action class")
}
return false
}
+17 -8
View File
@@ -3,6 +3,7 @@ package judgement
import (
"context"
"errors"
"fmt"
"github.com/samcharles93/archie-core/modules/connectors"
)
@@ -33,10 +34,17 @@ func (Reversibility) Judge(_ context.Context, a Action) (Verdict, error) {
return Verdict{}, errors.New("the connector declares no reversibility for this action")
}
// Precedent sets a ceiling from the action class's earned level. Until a
// class has history, it is the fresh-install default: read-only classes act
// quietly, every other class proposes and waits.
type Precedent struct{}
// ClassLevels says what level an action class stands at.
type ClassLevels interface {
Level(ctx context.Context, c Class, readOnly bool) (Level, error)
}
// Precedent sets a ceiling from the action class's current level. A class
// starts at its default (read-only classes act quietly, every other class
// proposes and waits) and stays wherever its history has put it.
type Precedent struct {
Classes ClassLevels
}
// Name is the guard's name in verdicts.
func (Precedent) Name() string { return "precedent" }
@@ -45,9 +53,10 @@ func (Precedent) Name() string { return "precedent" }
func (Precedent) Advisory() bool { return false }
// Judge returns the class's level.
func (Precedent) Judge(_ context.Context, a Action) (Verdict, error) {
if a.Effect.ReadOnly {
return Verdict{Ceiling: ActQuietly}, nil
func (p Precedent) Judge(ctx context.Context, a Action) (Verdict, error) {
level, err := p.Classes.Level(ctx, a.Class(), a.Effect.ReadOnly)
if err != nil {
return Verdict{}, fmt.Errorf("read class level: %w", err)
}
return Verdict{Ceiling: ProposeAndWait, Findings: []Finding{{Text: "this action class has no approvals yet"}}}, nil
return Verdict{Ceiling: level, Findings: []Finding{{Text: "this action class is at " + level.String()}}}, nil
}
+152
View File
@@ -0,0 +1,152 @@
package store
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/google/uuid"
)
// ErrNoClass means no class has that id.
var ErrNoClass = errors.New("no such action class")
// Class is one action class and the level it stands at.
type Class struct {
ID uuid.UUID `db:"id"`
OrgID string `db:"org_id"`
Connector string `db:"connector"`
Action string `db:"action"`
TargetKind string `db:"target_kind"`
Environment string `db:"environment"`
ReadOnly bool `db:"read_only"`
Level string `db:"level"`
CreatedAt time.Time `db:"created_at"`
ResetAt sql.NullTime `db:"reset_at"`
}
// ClassSummary is a class with how many decisions it holds.
type ClassSummary struct {
Class
Decisions int `db:"decisions"`
LastAt sql.NullTime `db:"last_at"`
}
// Reset is one return of a class to its default.
type Reset struct {
ID uuid.UUID `db:"id"`
FromLevel string `db:"from_level"`
ToLevel string `db:"to_level"`
By string `db:"by"`
At time.Time `db:"at"`
}
const classColumns = `id, org_id, connector, action, target_kind, environment, read_only, level, created_at, reset_at`
// EnsureClass returns the class c names, creating it at c.Level when it is
// new. An existing class keeps its level.
func (s *Store) EnsureClass(ctx context.Context, c Class) (Class, error) {
var out Class
err := s.db.GetContext(ctx, &out, `
INSERT INTO judgement.classes (id, org_id, connector, action, target_kind, environment, read_only, level)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
ON CONFLICT (org_id, connector, action, target_kind, environment)
DO UPDATE SET read_only = judgement.classes.read_only
RETURNING `+classColumns,
c.ID, c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, c.ReadOnly, c.Level)
if err != nil {
return Class{}, fmt.Errorf("ensure class: %w", err)
}
return out, nil
}
// Classes returns every class, most recently decided first.
func (s *Store) Classes(ctx context.Context, orgID string) ([]ClassSummary, error) {
var out []ClassSummary
err := s.db.SelectContext(ctx, &out, `
SELECT c.id, c.org_id, c.connector, c.action, c.target_kind, c.environment, c.read_only, c.level,
c.created_at, c.reset_at, count(d.id) AS decisions, max(d.created_at) AS last_at
FROM judgement.classes c
LEFT JOIN judgement.decisions d ON d.org_id = c.org_id AND d.connector = c.connector
AND d.action = c.action AND d.target_kind = c.target_kind AND d.environment = c.environment
WHERE c.org_id = $1
GROUP BY c.id
ORDER BY coalesce(max(d.created_at), c.created_at) DESC, c.id`, orgID)
if err != nil {
return nil, fmt.Errorf("list classes: %w", err)
}
return out, nil
}
// ClassByID returns one class.
func (s *Store) ClassByID(ctx context.Context, orgID string, id uuid.UUID) (Class, error) {
var out Class
err := s.db.GetContext(ctx, &out, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2`, orgID, id)
if errors.Is(err, sql.ErrNoRows) {
return Class{}, ErrNoClass
}
if err != nil {
return Class{}, fmt.Errorf("read class: %w", err)
}
return out, nil
}
// ClassDecisions returns a class's newest decisions, newest first.
func (s *Store) ClassDecisions(ctx context.Context, c Class, limit int) ([]Decision, error) {
var out []Decision
err := s.db.SelectContext(ctx, &out, `
SELECT id, org_id, run_id, key, connector, action, target_kind, environment, level, body, created_at
FROM judgement.decisions
WHERE org_id = $1 AND connector = $2 AND action = $3 AND target_kind = $4 AND environment = $5
ORDER BY created_at DESC, id LIMIT $6`,
c.OrgID, c.Connector, c.Action, c.TargetKind, c.Environment, limit)
if err != nil {
return nil, fmt.Errorf("list class decisions: %w", err)
}
return out, nil
}
// ClassResets returns a class's resets, newest first.
func (s *Store) ClassResets(ctx context.Context, id uuid.UUID) ([]Reset, error) {
var out []Reset
err := s.db.SelectContext(ctx, &out, `
SELECT id, from_level, to_level, by, at FROM judgement.class_resets
WHERE class_id = $1 ORDER BY at DESC, id`, id)
if err != nil {
return nil, fmt.Errorf("list class resets: %w", err)
}
return out, nil
}
// ResetClass sets a class to level and records the reset, in one transaction.
func (s *Store) ResetClass(ctx context.Context, orgID string, id uuid.UUID, level, by string, at time.Time) (Class, error) {
tx, err := s.db.BeginTxx(ctx, nil)
if err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
defer func() { _ = tx.Rollback() }()
var before Class
err = tx.GetContext(ctx, &before, `SELECT `+classColumns+` FROM judgement.classes WHERE org_id = $1 AND id = $2 FOR UPDATE`, orgID, id)
if errors.Is(err, sql.ErrNoRows) {
return Class{}, ErrNoClass
}
if err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
var out Class
if err := tx.GetContext(ctx, &out, `
UPDATE judgement.classes SET level = $2, reset_at = $3 WHERE id = $1 RETURNING `+classColumns, id, level, at); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO judgement.class_resets (id, org_id, class_id, from_level, to_level, by, at)
VALUES ($1, $2, $3, $4, $5, $6, $7)`, uuid.New(), orgID, id, before.Level, level, by, at); err != nil {
return Class{}, fmt.Errorf("record reset: %w", err)
}
if err := tx.Commit(); err != nil {
return Class{}, fmt.Errorf("reset class: %w", err)
}
return out, nil
}
@@ -7,6 +7,7 @@ import (
"database/sql"
"errors"
"fmt"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
@@ -24,6 +25,8 @@ type Decision struct {
Environment string `db:"environment"`
Level string `db:"level"`
Body []byte `db:"body"`
// CreatedAt is set by the database and read only by the class history.
CreatedAt time.Time `db:"created_at"`
}
// Store is the judgement module's Postgres store.
+32
View File
@@ -266,3 +266,35 @@ func TestExecuteApprovedRunsOnlyWhatThePersonSaw(t *testing.T) {
})
}
}
type classLevel struct{ level Level }
func (c classLevel) Level(context.Context, Class, bool) (Level, error) { return c.level, nil }
// TestPrecedentCeilingIsTheClassLevel guards the earned-autonomy seam: the
// precedent guard's ceiling is the level its action class stands at, not a
// default, so a class that was reset, raised or lowered judges accordingly.
func TestPrecedentCeilingIsTheClassLevel(t *testing.T) {
tests := []struct {
name string
level Level
read bool
}{
{name: "a read-only class at its default", level: ActQuietly, read: true},
{name: "a changing class raised to act and tell", level: ActAndTell},
{name: "a changing class at its default", level: ProposeAndWait},
{name: "a read-only class lowered to escalate", level: Escalate, read: true},
{name: "a class that never runs", level: Never},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
v, err := Precedent{Classes: classLevel{tt.level}}.Judge(t.Context(), Action{Effect: connectors.Effect{ReadOnly: tt.read}})
if err != nil {
t.Fatal(err)
}
if v.Ceiling != tt.level {
t.Fatalf("ceiling = %s, want the class level %s", v.Ceiling, tt.level)
}
})
}
}
+1
View File
@@ -34,6 +34,7 @@ function signOut() {
<nav v-if="signedIn" class="flex flex-1 items-center gap-3 text-label">
<RouterLink to="/composer" active-class="text-foreground" class="text-muted-foreground">Composer</RouterLink>
<RouterLink to="/runs" active-class="text-foreground" class="text-muted-foreground">Runs</RouterLink>
<RouterLink to="/classes" active-class="text-foreground" class="text-muted-foreground">Classes</RouterLink>
<RouterLink to="/settings" active-class="text-foreground" class="text-muted-foreground">Settings</RouterLink>
<Button variant="ghost" size="xs" class="ml-auto" @click="signOut">Sign out</Button>
</nav>
+156
View File
@@ -0,0 +1,156 @@
<script setup lang="ts">
import { onBeforeUnmount, ref, watch } from "vue";
import { useRouter } from "vue-router";
import PageHeader from "@/base/PageHeader.vue";
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
} from "@/components/ui/alert-dialog";
import { Badge } from "@/components/ui/badge";
import { Button } from "@/components/ui/button";
import { Empty, EmptyHeader, EmptyTitle } from "@/components/ui/empty";
import { ReadError } from "@/components/ui/read-error";
import { Section } from "@/components/ui/section";
import { Spinner } from "@/components/ui/spinner";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
import { Timestamp } from "@/components/ui/timestamp";
import { type ClassDetail, classDetail, resetClass, Unauthorized } from "./api";
import { className, levelLabel } from "./state";
/** One action class: its level, and every decision made in it. */
const props = defineProps<{ id: string }>();
const emit = defineEmits<{ unauthorized: [] }>();
const router = useRouter();
const detail = ref<ClassDetail>();
const loading = ref(true);
const error = ref("");
const confirming = ref(false);
const resetting = ref(false);
let controller = new AbortController();
async function load() {
controller.abort();
controller = new AbortController();
const signal = controller.signal;
loading.value = true;
error.value = "";
try {
const got = await classDetail(props.id, signal);
if (!signal.aborted) detail.value = got;
} catch (err) {
fail(err, signal);
} finally {
if (!signal.aborted) loading.value = false;
}
}
async function reset() {
resetting.value = true;
error.value = "";
try {
await resetClass(props.id);
await load();
} catch (err) {
fail(err, controller.signal);
} finally {
resetting.value = false;
}
}
function fail(err: unknown, signal: AbortSignal) {
if (signal.aborted) return;
if (err instanceof Unauthorized) emit("unauthorized");
error.value = err instanceof Error ? err.message : String(err);
}
watch(() => props.id, load, { immediate: true });
onBeforeUnmount(() => controller.abort());
</script>
<template>
<div>
<Spinner v-if="loading && !detail" />
<ReadError v-else-if="error && !detail" :message="error" retry-label="Retry" @retry="load" />
<template v-else-if="detail">
<PageHeader :title="className(detail)">
<Badge variant="outline">{{ levelLabel(detail.level) }}</Badge>
<Button variant="outline" size="sm" :disabled="resetting || detail.level === detail.default" @click="confirming = true">
Reset to {{ levelLabel(detail.default).toLowerCase() }}
</Button>
</PageHeader>
<ReadError v-if="error" :message="error" retry-label="Retry" @retry="load" />
<Section title="History">
<Empty v-if="detail.history.length === 0">
<EmptyHeader><EmptyTitle>No decisions yet</EmptyTitle></EmptyHeader>
</Empty>
<Table v-else>
<TableHeader>
<TableRow>
<TableHead>Target</TableHead>
<TableHead>Level</TableHead>
<TableHead>Approval</TableHead>
<TableHead>When</TableHead>
</TableRow>
</TableHeader>
<TableBody>
<TableRow
v-for="h in detail.history"
:key="h.decision_id"
class="cursor-pointer"
tabindex="0"
@click="router.push({ name: 'run', params: { id: h.run_id } })"
@keydown.enter="router.push({ name: 'run', params: { id: h.run_id } })"
>
<TableCell>{{ h.target }}</TableCell>
<TableCell>{{ h.refused_by ? `Refused by ${h.refused_by}` : levelLabel(h.level) }}</TableCell>
<TableCell>{{ h.approval }}<template v-if="h.answered_by"> by {{ h.answered_by }}</template></TableCell>
<TableCell><Timestamp :at="h.at" /></TableCell>
</TableRow>
</TableBody>
</Table>
</Section>
<Section v-if="detail.resets.length > 0" title="Resets" class="mt-4">
<Table>
<TableHeader>
<TableRow>
<TableHead>From</TableHead>
<TableHead>To</TableHead>
<TableHead>By</TableHead>
<TableHead>When</TableHead>
</TableRow>
</TableHeader>
<TableBody>
<TableRow v-for="r in detail.resets" :key="r.at">
<TableCell>{{ levelLabel(r.from) }}</TableCell>
<TableCell>{{ levelLabel(r.to) }}</TableCell>
<TableCell>{{ r.by }}</TableCell>
<TableCell><Timestamp :at="r.at" /></TableCell>
</TableRow>
</TableBody>
</Table>
</Section>
<AlertDialog :open="confirming" @update:open="(v: boolean) => (confirming = v)">
<AlertDialogContent>
<AlertDialogHeader>
<AlertDialogTitle>Reset class?</AlertDialogTitle>
<AlertDialogDescription>
{{ className(detail) }} returns to {{ levelLabel(detail.default).toLowerCase() }}. Its history stays.
</AlertDialogDescription>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel>Cancel</AlertDialogCancel>
<AlertDialogAction @click="reset">Reset</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
</template>
</div>
</template>
+74
View File
@@ -0,0 +1,74 @@
<script setup lang="ts">
import { onBeforeUnmount, onMounted, ref } from "vue";
import { useRouter } from "vue-router";
import PageHeader from "@/base/PageHeader.vue";
import { Badge } from "@/components/ui/badge";
import { Empty, EmptyHeader, EmptyTitle } from "@/components/ui/empty";
import { ReadError } from "@/components/ui/read-error";
import { Spinner } from "@/components/ui/spinner";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
import { Timestamp } from "@/components/ui/timestamp";
import { type ActionClass, listClasses, Unauthorized } from "./api";
import { levelLabel } from "./state";
const emit = defineEmits<{ unauthorized: [] }>();
const router = useRouter();
const classes = ref<ActionClass[]>([]);
const loading = ref(true);
const error = ref("");
const controller = new AbortController();
async function load() {
loading.value = true;
error.value = "";
try {
classes.value = await listClasses(controller.signal);
} catch (err) {
if (controller.signal.aborted) return;
if (err instanceof Unauthorized) emit("unauthorized");
error.value = err instanceof Error ? err.message : String(err);
} finally {
loading.value = false;
}
}
const open = (id: string) => router.push({ name: "class", params: { id } });
onMounted(load);
onBeforeUnmount(() => controller.abort());
</script>
<template>
<div>
<PageHeader title="Classes" />
<Spinner v-if="loading" />
<ReadError v-else-if="error" :message="error" retry-label="Retry" @retry="load" />
<Empty v-else-if="classes.length === 0">
<EmptyHeader><EmptyTitle>No action classes yet</EmptyTitle></EmptyHeader>
</Empty>
<Table v-else>
<TableHeader>
<TableRow>
<TableHead>Action</TableHead>
<TableHead>Target</TableHead>
<TableHead>Environment</TableHead>
<TableHead>Level</TableHead>
<TableHead>Decisions</TableHead>
<TableHead>Last</TableHead>
</TableRow>
</TableHeader>
<TableBody>
<TableRow v-for="c in classes" :key="c.id" class="cursor-pointer" tabindex="0" @click="open(c.id)" @keydown.enter="open(c.id)">
<TableCell>{{ c.connector }} {{ c.action }}</TableCell>
<TableCell>{{ c.target_kind }}</TableCell>
<TableCell>{{ c.environment }}</TableCell>
<TableCell><Badge variant="outline">{{ levelLabel(c.level) }}</Badge></TableCell>
<TableCell>{{ c.decisions }}</TableCell>
<TableCell><Timestamp v-if="c.last_decided_at" :at="c.last_decided_at" /></TableCell>
</TableRow>
</TableBody>
</Table>
</div>
</template>
+48
View File
@@ -174,6 +174,54 @@ export async function answerApproval(id: string, approved: boolean): Promise<voi
throw new Error(body.error ?? `${res.status} ${res.statusText}`);
}
}
export type Level = "act_quietly" | "act_and_tell" | "propose_and_wait" | "escalate" | "never";
export interface ActionClass {
id: string;
connector: string;
action: string;
target_kind: string;
environment: string;
level: Level;
default: Level;
decisions: number;
last_decided_at?: string;
reset_at?: string;
}
export interface HistoryEntry {
decision_id: string;
run_id: string;
target: string;
level: Level;
refused_by?: string;
approval?: "pending" | "approved" | "denied" | "expired";
answered_by?: string;
at: string;
}
export interface ClassDetail extends ActionClass {
history: HistoryEntry[];
resets: { from: Level; to: Level; by: string; at: string }[];
}
export const listClasses = (signal?: AbortSignal) => get<ActionClass[]>("/api/classes", signal);
export const classDetail = (id: string, signal?: AbortSignal) =>
get<ClassDetail>(`/api/classes/${encodeURIComponent(id)}`, signal);
/** Returns an action class to its default level; its history stays. */
export async function resetClass(id: string): Promise<void> {
const res = await fetch(`/api/classes/${encodeURIComponent(id)}/reset`, {
method: "POST",
headers: { Authorization: `Bearer ${token()}` },
});
if (res.status === 401) throw new Unauthorized("The admin token was refused.");
if (!res.ok) {
const body = (await res.json().catch(() => ({}))) as { error?: string };
throw new Error(body.error ?? `${res.status} ${res.statusText}`);
}
}
export const listRuns = (signal?: AbortSignal) => get<Run[]>("/api/runs", signal);
export const runTrail = (id: string, signal?: AbortSignal) => get<Trail>(`/api/runs/${encodeURIComponent(id)}`, signal);
+2
View File
@@ -6,6 +6,8 @@ export default createRouter({
{ path: "/", redirect: "/composer" },
{ path: "/composer", name: "composer", component: () => import("./ComposerView.vue") },
{ path: "/runs", name: "runs", component: () => import("./RunsView.vue") },
{ path: "/classes", name: "classes", component: () => import("./ClassesView.vue") },
{ path: "/classes/:id", name: "class", component: () => import("./ClassView.vue"), props: true },
{ path: "/settings", name: "settings", component: () => import("./SettingsView.vue") },
{ path: "/runs/:id", name: "run", component: () => import("./RunView.vue"), props: true },
],
+15 -1
View File
@@ -1,4 +1,4 @@
import type { Run } from "./api";
import type { Level, Run } from "./api";
/** The StatusDot tone for a run's state. */
export function runTone(state: Run["state"]): "ok" | "warn" | "danger" | "info" | "idle" {
@@ -16,3 +16,17 @@ export function runTone(state: Run["state"]): "ok" | "warn" | "danger" | "info"
return "idle";
}
}
const levelLabels: Record<Level, string> = {
act_quietly: "Act quietly",
act_and_tell: "Act and tell",
propose_and_wait: "Propose and wait",
escalate: "Escalate",
never: "Never",
};
export const levelLabel = (level: Level): string => levelLabels[level];
/** The class's own names, as one line. */
export const className = (c: { connector: string; action: string; target_kind: string; environment: string }): string =>
`${c.connector} ${c.action} on ${c.target_kind} in ${c.environment || "no environment"}`;