Feat: AIAC Event Broker + Keycloak SPI listener (phase 2, PR 2)

.github/workflows/security-scans.yaml

@@ -44,7 +44,21 @@ jobs:
           # version exists (affected <= 1.5.9, crewai pins chromadb < 1.2). The vulnerability
           # requires running a chromadb HTTP server with trust_remote_code=true, which the
           # github_agent demo does not do. See demo/agents/github_agent/pyproject.toml.
-          allow-ghsas: GHSA-f4j7-r4q5-qw2c
+          #
+          # keycloak-services (aiac/keycloak-spi, provided-scope): these are Keycloak *server*
+          # advisories, not code shipped in our provider jar (only jnats is shaded). They are
+          # remediated operationally by patching the Keycloak deployment; our pom + Dockerfile
+          # already track a patched line (26.6.4, see keycloak-spi/pom.xml). The three below have
+          # NO released fix (affected <= 26.6.4, patched version "None"), so they cannot be
+          # resolved by a version bump:
+          #   GHSA-wcvj-vpvw-9rr5  Improper Validation of Consistency within Input
+          #   GHSA-p3v8-fm5p-v84h  Improper Verification of Cryptographic Signature
+          #   GHSA-q6h7-xxp7-7429  Authentication Bypass by Primary Weakness
+          allow-ghsas: >-
+            GHSA-f4j7-r4q5-qw2c,
+            GHSA-wcvj-vpvw-9rr5,
+            GHSA-p3v8-fm5p-v84h,
+            GHSA-q6h7-xxp7-7429
 
   shellcheck:
     name: Shell Script Lint

aiac/CLAUDE.md

@@ -1,6 +1,6 @@
 # AIAC Codebase Guide
 
-All paths below are relative to `kagenti-extensions/aiac/`.
+All paths below are relative to `cortex/aiac/`.
 
 ## Requirements / PRD docs
 
@@ -50,23 +50,18 @@ Per-task handoff documents live under `docs/handoffs/` — one markdown file per
 
 ## Source code
 
-`src/aiac/` — Python package root (`__init__.py` is empty).
+`src/aiac/` — Python package root (`__init__.py` is empty). It is organized by
+subsystem: an IdP configuration layer, a PDP policy-writer layer, the AIAC Agent
+layer (built on the SPM/APM model — a Controller dispatching to use-case
+sub-agents and a policy-rules builder), and a two-layer policy stack (models, a
+model store, and the Policy Computation Engine).
 
-Key stable structure:
-- `idp/` — IdP configuration service and models
-- `pdp/` — PDP policy writer service and library
-- `agent/` — the AIAC Agent layer (rebuilt on the SPM/APM model):
-  - `agent/controller/` — FastAPI Controller (`routes.py` + Dockerfile); `/apply/*` routes dispatch to the UC sub-agents and make the single `compute_and_apply` (PCE) call
-  - `agent/uc/` — use-case sub-agents: `onboarding/` (provision + policy_builder + orchestrator), `policy_update/` (build/rebuild), `role_update/`
-  - `agent/policy_rules_builder/` — PRB: `build_role_rules` / `build_scope_rules` emit `list[PolicyRule]`
-  - `agent/shared/` — shared helpers (`roles.py`, e.g. `flatten_role`)
-  - `agent/onboarding.old/` — archived prior implementation (built on the superseded `ProposedDiff` model); not part of the active build
-- `policy/` — the two-layer policy stack (all implemented):
-  - `policy/model/` — `PolicyRule`, `ServicePolicyModel` (SPM), `AgentPolicyModel` (APM), `PolicyModel`
-  - `policy/store/` — Policy Store service + library (SPM CRUD)
-  - `policy/computation/` — Policy Computation Engine (`compute_and_apply`, SPM-based)
+Discover the concrete layout live rather than relying on a memorized tree:
 
-For current file list, `ls` or `find` under `src/aiac/`.
+```bash
+find src/aiac -maxdepth 2 -type d      # subsystems and their immediate children
+ls src/aiac/<subsystem>/               # drill into any layer
+```
 
 ## Tests
 
@@ -78,24 +73,32 @@ For current file list, `ls` or `find` under `src/aiac/`.
 .venv/bin/pytest test/ -m "not integration"
 ```
 
-The whole `test/` tree (including `test/policy/`) collects and runs green. The Policy
-Computation Engine (`aiac.policy.computation.engine`) was migrated to the SPM store surface in
-**Wave 3 / Handoff 05**, so the earlier PCE-chain collection failures (which required ignoring
-`test/policy/computation`, `test/agent/controller/test_routes.py`, and
-`test/integration/test_policy_pipeline.py`) are resolved — no `--ignore` flags are needed.
-
-Use `ls test/` to discover current test directories.
-
-**Integration tests** (`-m integration`) need live config — Keycloak + admin creds + an LLM
-endpoint (`opa` on PATH for the policy-pipeline suite). Those variables live in
+The whole `test/` tree collects and runs green — no `--ignore` flags are needed.
+(This wasn't always true: the Policy Computation Engine was migrated to the SPM
+store surface in Wave 3, which resolved the earlier PCE-chain collection
+failures.)
+
+Use `ls test/` / `find test -type d` to discover current test directories.
+
+**Integration tests** (`-m integration`) now close the **real OPA evaluation loop** — they onboard
+through the in-cluster Controller, then drive real HTTP requests **through AuthBridge** and assert the
+**deployed OPA plugin's** allow/deny (no `opa eval`, no `.rego` dump, so `opa` on PATH is no longer
+needed). They therefore need a live **rossoctl/Kind cluster with the AuthBridge OPA pipeline wired
+into both legs** (the demo `github-agent`/`github-tool` deployed + registered), plus Keycloak admin
+creds and an LLM endpoint for onboarding. Stand the pipeline up with `k8s/opa-kind-enable.sh`;
+the full prerequisites, wiring, and manual probe commands are in `k8s/opa-kind-runbook.md`, and the
+per-loop shape is documented in `test/integration/uc1_onboard.py`. Config lives in
 `test/integration/.env` (gitignored): `LLM_BASE_URL`, `LLM_API_KEY`, `LLM_MODEL`, `KEYCLOAK_URL`,
 `KEYCLOAK_ADMIN_USERNAME`, `KEYCLOAK_ADMIN_PASSWORD`. Source it before running:
 
 ```bash
+k8s/opa-kind-enable.sh          # one-time: wire the OPA plugin into the Kind cluster
 set -a; . test/integration/.env; set +a
 .venv/bin/pytest test/integration/ -m integration
 ```
 
+When the cluster is not wired or the env is unset, the suite **skips cleanly** (it never false-passes).
+
 **Smoke test** (requires live service at `AIAC_PDP_CONFIG_URL`, default `http://127.0.0.1:7071`):
 
 ```bash
@@ -106,26 +109,28 @@ Exercises all `Configuration` methods — run `ls test/idp/configuration/` to se
 
 ## Python environment
 
-Virtual environment: `kagenti-extensions/aiac/.venv`
+Virtual environment: `cortex/aiac/.venv`
 
-Activate: `source kagenti-extensions/aiac/.venv/bin/activate`
-Run directly: `kagenti-extensions/aiac/.venv/bin/python` / `kagenti-extensions/aiac/.venv/bin/pytest`
+Activate: `source cortex/aiac/.venv/bin/activate`
+Run directly: `cortex/aiac/.venv/bin/python` / `cortex/aiac/.venv/bin/pytest`
 
 Always use this venv for any Python execution, test runs, or dependency checks.
 
 ## Kubernetes & builds
 
 Config: `k8s/`, `pyproject.toml`, `pyrightconfig.json`
 
-Docker images:
+Docker images: each service ships a `Dockerfile` next to its service code (build
+context is `src/`, except `rag-ingest/`, which is a separate top-level
+directory). Discover the current set of images and their Dockerfiles live:
 
-| Image | Dockerfile location |
-|-------|-------------------|
-| `aiac-agent` | `src/aiac/agent/controller/Dockerfile` (build context `src/`) |
-| `aiac-pdp-config` | `src/aiac/idp/service/configuration/keycloak/Dockerfile` |
-| `aiac-pdp-policy-opa` | `src/aiac/pdp/service/policy/opa/Dockerfile` |
-| `aiac-policy-store` | `src/aiac/policy/store/service/Dockerfile` |
-| `aiac-rag-ingest` | `rag-ingest/` (separate directory) |
+```bash
+find src -name Dockerfile          # per-service Dockerfiles under src/
+ls rag-ingest/                     # the out-of-tree ingest image
+```
+
+Image names and build contexts are declared in the build/CI config and the
+`k8s/` manifests — grep there for the authoritative name→Dockerfile mapping.
 
 ### Non-root container / volume-ownership pattern
 
@@ -152,9 +157,12 @@ spec:
     fsGroup: 10001   # makes the mounted volume group-writable by UID 10001
 ```
 
-Services requiring this today:
-- **Policy store** — PVC at `/data` (SQLite backend), `policy-store-statefulset.yaml`
-- **PDP policy OPA writer** — emptyDir at `/rego` (`REGO_OUTPUT_DIR`), `pdp-interface-deployment.yaml`
+This applies to any service that writes to a mounted volume (a PVC or an
+emptyDir). Find them live by grepping the manifests for volume mounts / claims:
+
+```bash
+grep -rlniE 'volumeMounts|volumeClaimTemplates|emptyDir|persistentVolumeClaim' k8s/
+```
 
 Services that mount no volumes still need the Dockerfile `USER` directive; the
 pod-level `fsGroup`/volume-chown block above is only required for those that
@@ -196,7 +204,7 @@ demo workloads, which don't) and CPU/memory requests + limits.
 
 ## External references
 
-- [Kagenti Developer Guide](https://github.com/kagenti/kagenti/blob/main/docs/dev-guide.md) — upstream Kagenti dev guide: per-persona workflows (agent, tool, extensions developers, MCP gateway operators), Git/PR process, pre-commit hooks, feature flags, local Kagenti UI v2 development (React frontend + FastAPI backend, building/deploying images to Kubernetes), and HyperShift-based testing on ephemeral OpenShift clusters (cluster lifecycle, cost management, troubleshooting).
+- [Rosso Developer Guide](https://github.com/rossoctl/rossoctl/blob/main/docs/dev-guide.md) — upstream Rosso dev guide (formerly the Kagenti Developer Guide; Kagenti was renamed to Rosso): per-persona workflows (agent, tool, extensions developers, MCP gateway operators), Git/PR process, pre-commit hooks, feature flags (all new features must be gated behind a disabled-by-default `ROSSOCTL_FEATURE_FLAG_<NAME>` flag), local Rosso UI v2 development (React frontend + FastAPI backend, building/deploying images to Kubernetes), and HyperShift-based testing on ephemeral OpenShift clusters (cluster lifecycle, cost management, troubleshooting).
 
 ## Agent skills
 

aiac/demo/agents/github_agent/.dockerignore

@@ -0,0 +1,7 @@
+.venv
+
+# Secrets — never bake into the image
+.env
+
+# `expect` scripts
+test_startup.exp

aiac/demo/agents/github_agent/.env.template

@@ -0,0 +1,28 @@
+# Github Agent - configuration template
+# Copy to .env and fill in your values.
+
+# LLM configuration
+TASK_MODEL_ID=ollama/ibm/granite4:latest
+LLM_API_BASE=http://host.docker.internal:11434
+LLM_API_KEY=my_api_key
+MODEL_TEMPERATURE=0
+
+# MCP Tool endpoint
+MCP_URL=http://github-tool-mcp:9090/mcp
+
+# Agent service
+PORT=8000
+LOG_LEVEL=INFO
+
+# Optional: static GitHub PAT passed to MCP as Bearer token.
+# If unset, the inbound Authorization header (AuthBridge path) is forwarded instead.
+GITHUB_TOKEN=
+
+# Optional: override the URL advertised in the agent card
+AGENT_ENDPOINT=
+
+# Optional: override the curated tool allow-list (comma-separated tool names)
+ENABLED_TOOLS=
+
+# Optional: expected issuer of inbound JWTs (informational)
+ISSUER=

aiac/demo/agents/github_agent/Dockerfile

@@ -0,0 +1,15 @@
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+ARG RELEASE_VERSION="main"
+
+WORKDIR /app
+COPY . .
+RUN uv sync --no-cache --locked --link-mode copy
+
+ENV PRODUCTION_MODE=True \
+    HOME=/app \
+    RELEASE_VERSION=${RELEASE_VERSION}
+
+RUN chown -R 1001:1001 /app
+USER 1001
+
+CMD ["uv", "run", "--no-sync", "server"]

aiac/demo/agents/github_agent/README.md

@@ -0,0 +1,113 @@
+# github-agent
+
+An autonomous A2A agent that acts on a user's behalf against GitHub **source repositories** and an **issue/PR tracker**, using the [`github-tool-mcp`](https://github.com/kagenti/kagenti-extensions) MCP server.
+
+This agent implements the canonical `github-agent` used by the AIAC policy-pipeline integration test — the two skills match the policy scenario's `source_operations` and `issue_operations` roles.
+
+## Skills
+
+| Skill id | Name | Description |
+|---|---|---|
+| `source_operations` | Source repository operations | Browse and search code; read, create, and modify repository file contents, branches, and commits. |
+| `issue_operations` | Issue & PR tracker operations | Read, search, create, and update issues, comments, sub-issues, and pull requests. |
+
+## Prerequisite: `github-tool-mcp` (production tool)
+
+This agent connects to **`github-tool-mcp:9090/mcp`** — the production 44-tool MCP server — at `MCP_URL`.
+Deploy it before starting the agent:
+
+```
+authbridge/demos/github-issue/k8s/github-tool-deployment.yaml
+```
+
+> **Not the same as `demo/tools/github_tool/`.**
+> `demo/tools/github_tool/` is a simplified 4-tool stub (`source-read`, `source-write`, `issues-read`,
+> `issues-write`) deployed as Service `github-tool` for **UC-1 onboarding discovery** only.
+> The agent never connects to it — it connects to the production `github-tool-mcp` server which
+> exposes the 44-tool GitHub API federation.
+
+## Configuration
+
+All settings are read from environment variables (or a `.env` file). Copy one of the presets:
+
+| Preset | Description |
+|---|---|
+| `.env.ollama` | Default — local Ollama (ibm/granite4) |
+| `.env.openai` | OpenAI gpt-4o-mini |
+| `.env.claude` | Anthropic Claude Sonnet |
+| `.env.template` | Documented placeholder for all vars |
+
+### Variables
+
+| Variable | Description | Default |
+|---|---|---|
+| `TASK_MODEL_ID` | litellm model id | `ollama/ibm/granite4:latest` |
+| `LLM_API_BASE` | OpenAI-compatible base URL | `http://host.docker.internal:11434` |
+| `LLM_API_KEY` | LLM API key | `my_api_key` |
+| `MODEL_TEMPERATURE` | Sampling temperature | `0` |
+| `EXTRA_HEADERS` | Extra LLM headers (JSON) | `{}` |
+| `MCP_URL` | MCP tool endpoint | `http://github-tool-mcp:9090/mcp` |
+| `MCP_TIMEOUT` | MCP connect timeout (s) | `600` |
+| `ENABLED_TOOLS` | Override the curated tool allow-list (comma-separated) | (unset → default set) |
+| `PORT` | A2A listen port | `8000` |
+| `LOG_LEVEL` | Log level | `INFO` |
+| `GITHUB_TOKEN` | Static Bearer to MCP (else inbound passthrough) | (unset) |
+| `ISSUER` | Expected `iss` of inbound JWTs (informational) | (unset) |
+| `AGENT_ENDPOINT` | Override the URL advertised in the card | (unset) |
+
+## Running locally
+
+```bash
+cd aiac/demo/agents/github_agent
+cp .env.ollama .env          # or another preset
+uv sync
+uv run server
+# In another terminal:
+curl -s localhost:8000/.well-known/agent-card.json | python3 -m json.tool
+```
+
+Optionally, run `expect -f test_startup.exp` instead to check startup automatically.
+
+## Deploying to Kagenti (Kind cluster)
+
+Prerequisites: a running Kagenti cluster (Keycloak realm `kagenti`, namespace `team1`) with `github-tool-mcp` already deployed.
+
+1. **Build the image:**
+   ```bash
+   cd aiac/demo/agents/github_agent
+   podman build -t github-agent:latest .
+   # or: docker build -t github-agent:latest .
+   ```
+
+2. **Load into the Kind cluster:**
+   ```bash
+   kind load docker-image github-agent:latest --name kagenti
+   ```
+
+3. **Apply manifests:**
+   ```bash
+   kubectl apply -f k8s/configmaps.yaml
+   kubectl apply -f k8s/github-agent-deployment.yaml
+   ```
+
+4. **Confirm AuthBridge injection:**
+   ```bash
+   kubectl get pod -n team1 -l app.kubernetes.io/name=github-agent -o jsonpath='{.items[0].spec.containers[*].name}'
+   ```
+   You should see the `authbridge-proxy` (or `envoy-proxy`) sidecar alongside `agent`.
+
+5. **Port-forward and send a message:**
+   ```bash
+   kubectl port-forward svc/github-agent 8080:8080 -n team1 &
+   # Send an A2A message/send request:
+   curl -s http://localhost:8080/.well-known/agent-card.json | python3 -m json.tool
+   ```
+
+## Architecture
+
+```
+A2A client ──(JSON-RPC /)──► github-agent (:8000)
+                                 │  CrewAI: prereq extract → researcher
+                                 └──(streamable-http, MCP_URL)──► github-tool-mcp:9090/mcp ──► GitHub
+      (AuthBridge sidecar: inbound JWT validation; outbound RFC-8693 token exchange for MCP_URL host)
+```