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", "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 }, }), } }