Archie runs its own agent loop only. Removes Kit resolution and launch, the harness runner and adapters, the setup terminal and sandbox view, harness secrets and OAuth capture (table dropped in migration 0075), the task-tools contract that only Kit containers reached, and the sandbox-kit-spec dependency. Agent profiles carry image and tools only. The egress proxy keeps the model-session path; the sandbox relay code stays for #1867.
509 lines
19 KiB
Go
509 lines
19 KiB
Go
package webui
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/health"
|
|
"github.com/samcharles93/archie-core/internal/domain/identity"
|
|
"github.com/samcharles93/archie-core/internal/domain/org"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
)
|
|
|
|
// authorize wraps h with the policy chain. A chain that is absent or has not
|
|
// loaded refuses the request: the credential check alone is never the gate
|
|
// while orgs exist, so a State Store outage closes the dashboard rather than
|
|
// letting every request through as the system org.
|
|
func (s *Server) authorize(h http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
// Checked before the principal: resolving it is a State Store round
|
|
// trip, which buys nothing when the answer is a refusal anyway.
|
|
if s.Access == nil || !s.Access.Ready() {
|
|
s.refuseUngated(w, r)
|
|
return
|
|
}
|
|
principal, err := s.requestPrincipal(r.Context())
|
|
if err != nil {
|
|
if wantsDocument(r) {
|
|
s.authPage(w, http.StatusUnauthorized, "Sign-in could not resolve your org.")
|
|
return
|
|
}
|
|
http.Error(w, "principal unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
if principal, err = s.selectedOrg(w, r, principal); err != nil {
|
|
http.Error(w, "principal unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
ctx := org.WithOrg(access.WithPrincipal(r.Context(), principal), principal.Org)
|
|
action, kind, id := accessRequest(r.WithContext(ctx))
|
|
// The record's org is not loaded here: org-filtered lookups keep a
|
|
// record of another org from ever being fetched, and this request's
|
|
// record (when it has an ID) belongs to the caller's org. The
|
|
// workspace, owner and state are read from the record, never the body.
|
|
resource, err := s.recordResource(ctx, kind, id)
|
|
if err != nil {
|
|
s.logf("record workspace unavailable", "kind", kind, "id", id, "err", err)
|
|
http.Error(w, "record unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
peer, _, _ := net.SplitHostPort(r.RemoteAddr)
|
|
decision := s.Access.Authorize(principal, action, resource, access.Context{Addr: peer})
|
|
if !decision.Allowed {
|
|
if errors.Is(decision.Err, access.ErrChainUnavailable) {
|
|
// Nothing was evaluated: the chain has not loaded. This is an
|
|
// availability failure, not a denial, so none is recorded.
|
|
s.refuseUngated(w, r)
|
|
return
|
|
}
|
|
s.recordDenial(r.Context(), principal, action, resource, decision)
|
|
if wantsDocument(r) {
|
|
s.authPage(w, http.StatusUnauthorized, "You do not have permission to do that.")
|
|
return
|
|
}
|
|
// A denial inside the caller's org is forbidden, without the
|
|
// reason.
|
|
http.Error(w, "forbidden", http.StatusForbidden)
|
|
return
|
|
}
|
|
// The principal rides the context into every State Store call, which
|
|
// derives the org it acts in from it.
|
|
h.ServeHTTP(w, r.WithContext(ctx))
|
|
})
|
|
}
|
|
|
|
// authorizeCreateIn checks a create against the workspace the body names, which
|
|
// the route-level check cannot see: no record exists yet to read it from. An
|
|
// empty workspace is the default one, which that check already covered.
|
|
func (s *Server) authorizeCreateIn(w http.ResponseWriter, r *http.Request, kind access.ResourceKind, workspace org.WorkspaceID) bool {
|
|
principal, ok := access.PrincipalFromContext(r.Context())
|
|
if workspace == "" || !ok {
|
|
return true
|
|
}
|
|
resource := access.Resource{Kind: kind, Org: principal.Org, Workspace: workspace}
|
|
decision := s.Access.Authorize(principal, access.ActionCreate, resource, access.Context{})
|
|
if decision.Allowed {
|
|
return true
|
|
}
|
|
s.recordDenial(r.Context(), principal, access.ActionCreate, resource, decision)
|
|
http.Error(w, "forbidden", http.StatusForbidden)
|
|
return false
|
|
}
|
|
|
|
// recordResource reads policy attributes from the stored record, never the body.
|
|
func (s *Server) recordResource(ctx context.Context, kind access.ResourceKind, id string) (access.Resource, error) {
|
|
resource := access.Resource{Kind: kind, ID: id, Org: org.OrgFromContext(ctx)}
|
|
if id == "" {
|
|
return resource, nil
|
|
}
|
|
var err error
|
|
switch kind {
|
|
case access.KindTask:
|
|
return s.taskResource(ctx, resource)
|
|
case access.KindBinding:
|
|
return s.bindingResource(ctx, resource)
|
|
case access.KindSource:
|
|
resource.Workspace, err = s.sourceWorkspace(ctx, id)
|
|
case access.KindMapping:
|
|
resource.Workspace, err = s.mappingWorkspace(ctx, id)
|
|
case access.KindEventType:
|
|
resource.Workspace, err = s.eventTypeWorkspace(ctx, id)
|
|
}
|
|
return resource, err
|
|
}
|
|
|
|
func (s *Server) sourceWorkspace(ctx context.Context, path string) (org.WorkspaceID, error) {
|
|
if s.Sources == nil {
|
|
return "", nil
|
|
}
|
|
src, err := s.Sources.GetSource(ctx, path)
|
|
if src == nil || err != nil {
|
|
return "", err
|
|
}
|
|
return src.WorkspaceID, nil
|
|
}
|
|
|
|
func (s *Server) bindingResource(ctx context.Context, resource access.Resource) (access.Resource, error) {
|
|
if s.Bindings == nil {
|
|
return resource, nil
|
|
}
|
|
b, err := s.Bindings.GetBinding(ctx, resource.ID)
|
|
if b == nil || err != nil {
|
|
return resource, ignoreNotFound(err, storecontract.ErrBindingNotFound)
|
|
}
|
|
resource.Workspace, resource.State = b.WorkspaceID, string(b.Status)
|
|
return resource, nil
|
|
}
|
|
|
|
func (s *Server) mappingWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) {
|
|
if s.Mappings == nil {
|
|
return "", nil
|
|
}
|
|
m, err := s.Mappings.GetMapping(ctx, id)
|
|
if m == nil || err != nil {
|
|
return "", ignoreNotFound(err, storecontract.ErrMappingNotFound)
|
|
}
|
|
return m.WorkspaceID, nil
|
|
}
|
|
|
|
func (s *Server) eventTypeWorkspace(ctx context.Context, id string) (org.WorkspaceID, error) {
|
|
if s.EventTypes == nil {
|
|
return "", nil
|
|
}
|
|
types, err := s.EventTypes.ListEventTypes(ctx)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
for _, t := range types {
|
|
if t.ID == id {
|
|
return t.WorkspaceID, nil
|
|
}
|
|
}
|
|
return "", nil
|
|
}
|
|
|
|
func (s *Server) taskResource(ctx context.Context, resource access.Resource) (access.Resource, error) {
|
|
taskID, ok := numericID(resource.ID)
|
|
if !ok {
|
|
return resource, nil
|
|
}
|
|
t, err := s.Store.TaskByID(ctx, taskID)
|
|
if t == nil || err != nil {
|
|
return resource, err
|
|
}
|
|
resource.Workspace, resource.Owner, resource.State = t.Workspace, identity.IdentityID(t.Identity), t.Status
|
|
return resource, nil
|
|
}
|
|
|
|
// numericID parses a task route's ID; any other segment names no task.
|
|
func numericID(id string) (int64, bool) {
|
|
n, err := strconv.ParseInt(id, 10, 64)
|
|
return n, err == nil
|
|
}
|
|
|
|
// ignoreNotFound drops the store's not-found answer: a missing record has no
|
|
// workspace, and the handler reports it.
|
|
func ignoreNotFound(err, notFound error) error {
|
|
if errors.Is(err, notFound) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
// refuseUngated answers a request the dashboard cannot authorize because no
|
|
// policy chain is available. It serves nothing ungated: without a chain the
|
|
// credential check would be the whole gate and every call would act as the
|
|
// system org. The detailed health report names only the unloaded chain, so
|
|
// the operator can see why without any other probe being served ungated.
|
|
func (s *Server) refuseUngated(w http.ResponseWriter, r *http.Request) {
|
|
if wantsDocument(r) {
|
|
s.authPage(w, http.StatusServiceUnavailable, "The access policy chain is not available yet.")
|
|
return
|
|
}
|
|
w.Header().Set("Cache-Control", "no-store")
|
|
if r.URL.Path == healthDetailedRoute {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusServiceUnavailable)
|
|
_ = json.NewEncoder(w).Encode(health.Report{Status: health.StatusDegraded, Components: []health.Component{{
|
|
Name: "access_policies", Status: health.StatusDegraded, Detail: "policies not loaded; requests refused",
|
|
}}})
|
|
return
|
|
}
|
|
http.Error(w, "access policies are not available", http.StatusServiceUnavailable)
|
|
}
|
|
|
|
// requestPrincipal assembles the principal a request acts as. With no acting
|
|
// identity (the shared token), it is the org-sys owner person when the upgrade
|
|
// created one; with an acting identity, it is the identity's org and
|
|
// memberships, read over the wire. The system owner remains the fallback for an
|
|
// install that has not run the operator phase.
|
|
func (s *Server) requestPrincipal(ctx context.Context) (access.Principal, error) {
|
|
if acting, ok := ActingIdentity(ctx); ok {
|
|
if s.Principals == nil {
|
|
return access.Principal{}, errPrincipalsUnavailable
|
|
}
|
|
return s.Principals.PrincipalFor(ctx, acting.ID)
|
|
}
|
|
if s.Principals != nil {
|
|
if operator, err := s.Principals.PrincipalFor(ctx, identity.OperatorID()); err == nil &&
|
|
operator.Org == org.DefaultOrgID && operator.Role("") == org.RoleOwner {
|
|
return operator, nil
|
|
}
|
|
}
|
|
return access.SharedTokenOwner(), nil
|
|
}
|
|
|
|
func (s *Server) recordDenial(ctx context.Context, p access.Principal, action access.Action, r access.Resource, decision access.Decision) {
|
|
if s.Denials == nil {
|
|
return
|
|
}
|
|
denial := access.Denial{
|
|
Principal: p.IdentityID, Org: p.Org, Action: action,
|
|
Kind: r.Kind, ResourceID: r.ID, Level: decision.Level,
|
|
Policies: decision.Policies,
|
|
}
|
|
if err := s.Denials.RecordDenial(ctx, denial); err != nil && s.Log != nil {
|
|
s.Log.ErrorContext(ctx, "record access denial", "err", err)
|
|
}
|
|
}
|
|
|
|
// errPrincipalsUnavailable is the answer of a dashboard wired with the chain
|
|
// but without the principal assembly, which is a composition error: the two
|
|
// are wired together or not at all.
|
|
var errPrincipalsUnavailable = ¬WiredError{}
|
|
|
|
type notWiredError struct{}
|
|
|
|
func (*notWiredError) Error() string { return "webui: principal assembly not wired" }
|
|
|
|
// accessRequest derives the action, resource kind and record key of one API
|
|
// request from its method and path. Unmapped routes read the dashboard
|
|
// itself, so a new route is never wider than read until it is mapped.
|
|
func accessRequest(r *http.Request) (access.Action, access.ResourceKind, string) {
|
|
action := actionOf(r.Method)
|
|
path := r.URL.Path
|
|
if matchPrefix(path, "/api/audit") {
|
|
// The feed spans every trail, so reading it is its own action: the
|
|
// export route below the same prefix carries the same grant.
|
|
return access.ActionReadAudit, access.KindAudit, ""
|
|
}
|
|
if matchPrefix(path, "/api/usage") {
|
|
// Who spent what is its own grant, not a viewer's broad read.
|
|
return access.ActionReadUsage, access.KindDashboard, ""
|
|
}
|
|
if a, kind, id, ok := routeOverride(r, action, path); ok {
|
|
return a, kind, id
|
|
}
|
|
return action, kindOf(path), segmentValue(path, 2)
|
|
}
|
|
|
|
// actionOf maps the HTTP method onto the action vocabulary. POST is create:
|
|
// the route refinements lift the routes whose write is something else.
|
|
func actionOf(method string) access.Action {
|
|
switch method {
|
|
case http.MethodPost:
|
|
return access.ActionCreate
|
|
case http.MethodPut, http.MethodPatch:
|
|
return access.ActionUpdate
|
|
case http.MethodDelete:
|
|
return access.ActionDelete
|
|
}
|
|
return access.ActionRead
|
|
}
|
|
|
|
// routeOverride returns the action, kind and record key a specific route
|
|
// shape carries, or ok=false when the method-and-kind fallback applies.
|
|
func routeOverride(r *http.Request, action access.Action, path string) (access.Action, access.ResourceKind, string, bool) {
|
|
if a, kind, ok := accountRoute(path); ok {
|
|
return a, kind, "", true
|
|
}
|
|
if command, ok := bindingCommand(action, path); ok {
|
|
return command, access.KindBinding, segmentValue(path, 2), true
|
|
}
|
|
switch {
|
|
case matchSegment(path, "/api/tasks/", "/logs"):
|
|
return access.ActionReadLogs, access.KindTask, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/access"):
|
|
return accessRoute(action, path)
|
|
case matchPrefix(path, "/api/identities"):
|
|
return actionManage(action), access.KindIdentity, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/orgs"):
|
|
return orgRouteAction(action, path), access.KindOrg, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/schedules"):
|
|
return scheduleRoute(r, action, path)
|
|
case matchPrefix(path, "/api/extensions"):
|
|
// Installing and enabling an extension runs a process on the host.
|
|
return actionManage(action), access.KindPolicy, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/control-plane/resources"):
|
|
return controlPlaneResourceRoute(action, path)
|
|
case updateCommandRoute(action, path):
|
|
// Triggering or deferring an install changes the update object, not
|
|
// a workflow run: the dashboard kind carries the update's policy.
|
|
return access.ActionUpdate, access.KindDashboard, "update", true
|
|
case matchPrefix(path, "/api/chat"):
|
|
return chatRoute(action)
|
|
case matchSegment(path, "/api/sources/", "/secret"):
|
|
// Rotating a source's secret hands back its value.
|
|
return access.ActionReadSecret, access.KindSecret, segmentValue(path, 2), true
|
|
case matchPrefix(path, "/api/channels"), matchPrefix(path, "/api/config"),
|
|
matchPrefix(path, "/api/logs"), matchPrefix(path, "/api/tokens"):
|
|
return dashboardRoute(action, path)
|
|
}
|
|
return action, "", "", false
|
|
}
|
|
|
|
// dashboardRoute maps the dashboard's own routes: channel settings are
|
|
// instance administration, while config, logs and a person's own tokens act
|
|
// only as that person, needing no more than a dashboard read.
|
|
func dashboardRoute(action access.Action, path string) (access.Action, access.ResourceKind, string, bool) {
|
|
if matchPrefix(path, "/api/channels") {
|
|
return actionManage(action), access.KindDashboard, segmentValue(path, 2), true
|
|
}
|
|
return access.ActionRead, access.KindDashboard, "", true
|
|
}
|
|
|
|
// scheduleRoute maps a schedule request. A schedule the system org owns runs
|
|
// unattended as the instance, so there it is the same administration as a
|
|
// control-plane resource. A schedule another org owns fires in that org, so
|
|
// there it is an ordinary org resource its members may create and update.
|
|
func scheduleRoute(r *http.Request, action access.Action, path string) (access.Action, access.ResourceKind, string, bool) {
|
|
if p, ok := access.PrincipalFromContext(r.Context()); ok && p.Org != org.DefaultOrgID {
|
|
return action, access.KindSchedule, segmentValue(path, 2), true
|
|
}
|
|
return actionManage(action), access.KindPolicy, segmentValue(path, 2), true
|
|
}
|
|
|
|
// controlPlaneResourceRoute maps a control-plane resource request. History
|
|
// returns the raw stored revisions, including secret references and policy
|
|
// text, because restore re-applies the real value: that is stronger than the
|
|
// redacted feed's read_audit grant, so it is policy management of that kind.
|
|
// Everything else falls back to the managed-resource action.
|
|
func controlPlaneResourceRoute(action access.Action, path string) (access.Action, access.ResourceKind, string, bool) {
|
|
if matchSegment(path, "/api/control-plane/resources/", "/history") {
|
|
return access.ActionManagePolicies, access.KindPolicy, segmentValue(path, 3), true
|
|
}
|
|
return actionManage(action), access.KindPolicy, segmentValue(path, 3), true
|
|
}
|
|
|
|
// bindingCommand maps a binding lifecycle route to its action: approving arms
|
|
// a binding, so it is approval; pausing and resuming change its state.
|
|
func bindingCommand(action access.Action, path string) (access.Action, bool) {
|
|
switch {
|
|
case action != access.ActionCreate:
|
|
return action, false
|
|
case matchSegment(path, "/api/bindings/", "/approve"):
|
|
return access.ActionApprove, true
|
|
case matchSegment(path, "/api/bindings/", "/pause"), matchSegment(path, "/api/bindings/", "/resume"):
|
|
return access.ActionUpdate, true
|
|
}
|
|
return action, false
|
|
}
|
|
|
|
// orgRouteAction maps an org request: reads are org reads, changing who
|
|
// belongs to the org or which agents serve it is member management (an
|
|
// admin's grant), and any other mutation updates the org.
|
|
func orgRouteAction(action access.Action, path string) access.Action {
|
|
switch {
|
|
case action == access.ActionRead:
|
|
return access.ActionRead
|
|
case segmentValue(path, 3) == "members", segmentValue(path, 3) == "agents":
|
|
return access.ActionManageMembers
|
|
}
|
|
return access.ActionUpdate
|
|
}
|
|
|
|
// updateCommandRoute reports whether the request is one of the chat update
|
|
// commands, which act on the update object rather than running a workflow.
|
|
func updateCommandRoute(action access.Action, path string) bool {
|
|
return action == access.ActionCreate &&
|
|
(path == "/api/chat/update/install" || path == "/api/chat/update/defer")
|
|
}
|
|
|
|
// chatRoute maps a chat request: posting runs a workflow, anything else reads
|
|
// the dashboard.
|
|
func chatRoute(action access.Action) (access.Action, access.ResourceKind, string, bool) {
|
|
if action == access.ActionCreate {
|
|
return access.ActionRun, access.KindWorkflow, "", true
|
|
}
|
|
return access.ActionRead, access.KindDashboard, "", true
|
|
}
|
|
|
|
// kindOf maps a collection route onto the resource kind it addresses.
|
|
func kindOf(path string) access.ResourceKind {
|
|
switch {
|
|
case matchPrefix(path, "/api/tasks"):
|
|
return access.KindTask
|
|
case matchPrefix(path, "/api/event-types"):
|
|
return access.KindEventType
|
|
case matchPrefix(path, "/api/mappings"):
|
|
return access.KindMapping
|
|
case matchPrefix(path, "/api/bindings"):
|
|
return access.KindBinding
|
|
case matchPrefix(path, "/api/sources"):
|
|
return access.KindSource
|
|
case matchPrefix(path, "/api/work-requests"), matchPrefix(path, "/api/repositories"):
|
|
return access.KindTask
|
|
}
|
|
return access.KindDashboard
|
|
}
|
|
|
|
// accessRoute maps the access routes: policy management on the policies
|
|
// routes, and on the denials route the same read_audit grant the audit feed
|
|
// carries, which the shipped role policies give an org's admins and owners
|
|
// only -- denial records are the access trail's operator surface.
|
|
func accessRoute(action access.Action, path string) (access.Action, access.ResourceKind, string, bool) {
|
|
if matchPrefix(path, "/api/access/policies") {
|
|
return policyAction(action), access.KindPolicy, "", true
|
|
}
|
|
return access.ActionReadAudit, access.KindAudit, "", true
|
|
}
|
|
|
|
// policyAction lifts every write on the policy routes to manage_policies.
|
|
func policyAction(action access.Action) access.Action {
|
|
if action == access.ActionRead {
|
|
return action
|
|
}
|
|
return access.ActionManagePolicies
|
|
}
|
|
|
|
// actionManage lifts a create or update on a managed surface to the manage
|
|
// action the role vocabulary carries.
|
|
func actionManage(action access.Action) access.Action {
|
|
switch action {
|
|
case access.ActionCreate, access.ActionUpdate:
|
|
return access.ActionManageIdentities
|
|
case access.ActionDelete:
|
|
return access.ActionDelete
|
|
}
|
|
return action
|
|
}
|
|
|
|
// segmentValue returns the value of the n-th (0-based) segment of an API
|
|
// path, or "" when the path is shorter: /api/tasks/7/changes -> 7 is segment
|
|
// 2.
|
|
func segmentValue(path string, n int) string {
|
|
segments := splitPath(path)
|
|
if n < len(segments) {
|
|
return segments[n]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func splitPath(path string) []string {
|
|
var out []string
|
|
for segment := range strings.SplitSeq(path, "/") {
|
|
if segment != "" {
|
|
out = append(out, segment)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func matchPrefix(path, prefix string) bool {
|
|
return strings.HasPrefix(path, prefix+"/") || path == prefix
|
|
}
|
|
|
|
func matchSegment(path, prefix, suffix string) bool {
|
|
return strings.HasPrefix(path, prefix) && strings.HasSuffix(path, suffix)
|
|
}
|
|
|
|
func accountRoute(path string) (access.Action, access.ResourceKind, bool) {
|
|
switch path {
|
|
case "/api/accounts":
|
|
return access.ActionManageMembers, access.KindMember, true
|
|
case "/api/orgs/current":
|
|
// Choosing an org is open to any member; the handler checks the
|
|
// membership.
|
|
return access.ActionRead, access.KindDashboard, true
|
|
case "/api/authentication":
|
|
return access.ActionManageIdentities, access.KindIdentity, true
|
|
}
|
|
return "", "", false
|
|
}
|