Files
archie/internal/gateway/integration_tools.go
T
sam 41f44c43a1 feat(workflow): issue routing is a control-plane setting edited in the dashboard (#1959)
Label to workflow rules and a default workflow are the intake-routes
resource: ordered, case-insensitive, first rule wins, seeded with bug to
tdd, feature to feasibility, default triage. A write naming an undefined
workflow or an empty label is refused. The daemon reads it through the
workflow definitions client when pinning a task and at intake.

The kind indirection only carried this routing, so it is removed: the
per-kind NATS subjects (every consumer already bound archie.task.>) are
one subject, the envelope and playbook triggers lose their kind, and
x-intake-routes is dropped. The dashboard gets an Issue routing page
under Automation; the trigger card reads the same setting.
2026-11-13 20:28:52 +11:00

126 lines
5.1 KiB
Go

package gateway
import (
"context"
"encoding/json"
"fmt"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/tools"
)
// IntegrationSource is what the integration tools read, in the caller's org.
type IntegrationSource interface {
Resource(ctx context.Context, kind string) (json.RawMessage, error)
EventTypes(ctx context.Context) ([]eventtype.EventType, error)
Bindings(ctx context.Context) ([]binding.Binding, error)
Policies(ctx context.Context) ([]access.Policy, error)
}
// readableKinds are the settings that shape what a workflow can do, what starts
// it and what it is told to do. Provider, channel and connection settings are
// left out: they carry endpoints and secret references an agent has no use for.
// soul is the instructions text, task-policy and org-model-policy carry limits
// and settings whose secrets are references, never values.
var readableKinds = []string{
"workflow-execution-settings", "workflow-enablement", "intake-routes", "agent-profiles", "skills",
"eda-playbooks", "credential-bindings", "identity-grants",
"soul", "task-policy", "org-model-policy",
}
// visiblePolicies keeps what the caller's dashboard shows: the caller org's
// policies, and the instance policies when the caller owns the instance.
func visiblePolicies(ctx context.Context, policies []access.Policy) []access.Policy {
principal, ok := access.PrincipalFromContext(ctx)
if !ok {
return nil
}
out := make([]access.Policy, 0, len(policies))
for _, policy := range policies {
instance := policy.Level == access.LevelInstance
if (instance && principal.InstanceAdmin()) || (!instance && policy.OrgID == principal.Org) {
out = append(out, policy)
}
}
return out
}
// IntegrationTools returns read-only tools for investigating what starts
// workflows and how they can be customised. Nil source registers none.
// Each is checked as the dashboard checks the same read.
func IntegrationTools(source IntegrationSource, authz access.Authorizer) []tools.ToolEntry {
if source == nil || authz == nil {
return nil
}
return []tools.ToolEntry{
guarded(authz, access.ActionRead, access.KindPolicy, inputID("kind"), tools.ToolEntry{
Name: "settings_get",
Toolset: "workflows",
Description: "Return one settings document as JSON. Kinds: " + strings.Join(readableKinds, ", ") + ".",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{
"type": "object",
"properties": map[string]any{"kind": map[string]any{"type": "string", "enum": readableKinds}},
"required": []any{"kind"},
},
Handler: func(ctx context.Context, input map[string]any) (any, error) {
kind := asString(input["kind"])
if !slices.Contains(readableKinds, kind) {
return nil, fmt.Errorf("settings_get: %q is not readable; use one of %s", kind, strings.Join(readableKinds, ", "))
}
value, err := source.Resource(ctx, kind)
if err != nil {
return nil, fmt.Errorf("settings_get: %w", err)
}
return value, nil
},
}),
guarded(authz, access.ActionRead, access.KindEventType, nil, tools.ToolEntry{
Name: "event_types_list",
Toolset: "workflows",
Description: "List the named event types: each one's source, the rule that recognises it and the fields its payload carries.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{"type": "object", "properties": map[string]any{}},
Handler: func(ctx context.Context, _ map[string]any) (any, error) {
types, err := source.EventTypes(ctx)
if err != nil {
return nil, fmt.Errorf("event_types_list: %w", err)
}
return types, nil
},
}),
guarded(authz, access.ActionRead, access.KindPolicy, nil, tools.ToolEntry{
Name: "access_policies_list",
Toolset: "workflows",
Description: "List the Cedar access policies that decide what a workflow and its caller may do: each one's id, level, scope and policy text.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{"type": "object", "properties": map[string]any{}},
Handler: func(ctx context.Context, _ map[string]any) (any, error) {
policies, err := source.Policies(ctx)
if err != nil {
return nil, fmt.Errorf("access_policies_list: %w", err)
}
return visiblePolicies(ctx, policies), nil
},
}),
guarded(authz, access.ActionRead, access.KindBinding, nil, tools.ToolEntry{
Name: "bindings_list",
Toolset: "workflows",
Description: "List the bindings that start workflows from events: what each matches, its filter and the workflow it runs.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{"type": "object", "properties": map[string]any{}},
Handler: func(ctx context.Context, _ map[string]any) (any, error) {
bindings, err := source.Bindings(ctx)
if err != nil {
return nil, fmt.Errorf("bindings_list: %w", err)
}
return bindings, nil
},
}),
}
}