Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

test(security): prove Codex proxy network containment

Alfredo Lopezbebb08ced650
diff --git a/Makefile b/Makefile
index f6b37e43d..b000e8ace 100644
--- a/Makefile
+++ b/Makefile
@@ -1002,6 +1002,11 @@ test-e2e-wrc-internal-dependency-networkpolicy: ## Run issue #485 WRC internal-d
@echo "Running WRC internal-dependency NetworkPolicy E2E gate..."
KUBECONTEXT=$(E2E_KUBECONTEXT) bash scripts/e2e/e2e-wrc-internal-dependency-networkpolicy.sh
+.PHONY: test-e2e-codex-subscription-network-boundary
+test-e2e-codex-subscription-network-boundary: ## Codex LLM proxy NetworkPolicy boundary (exit 3 before deploy)
+ @echo "Running Codex subscription network-boundary gate..."
+ KUBECONTEXT=$(E2E_KUBECONTEXT) bash scripts/e2e/e2e-codex-subscription-network-boundary.sh
+
.PHONY: test-e2e-plugin-workload-sdk
test-e2e-plugin-workload-sdk: ## Run Plugin Workload SDK E2E gate (minikube only; requires E2E_PLUGIN_SDK_WRITE_CONFIRM=1)
@echo "Running Plugin Workload SDK E2E gate..."
diff --git a/deploy/base/control-plane/configmaps.yaml b/deploy/base/control-plane/configmaps.yaml
index 6e7096951..2c35e4d6f 100644
--- a/deploy/base/control-plane/configmaps.yaml
+++ b/deploy/base/control-plane/configmaps.yaml
@@ -24,6 +24,7 @@ data:
CONTROL_API_ADMIN_JWT_AUDIENCE: control-ui
CONTROL_API_ADMIN_JWT_TTL_SECONDS: '3600'
CONTROL_API_CODEX_SUBSCRIPTION_ENABLED: 'false'
+ # ClusterIP admin port only. NetworkPolicy admits Control API, not siblings.
CODEX_LLM_PROXY_ADMIN_URL: http://codex-llm-proxy.control-plane.svc.cluster.local:8081
CONTROL_API_ADMIN_BOOTSTRAP_USERNAME: admin
CONTROL_API_ADMIN_BOOTSTRAP_EMAIL: ''
@@ -95,8 +96,6 @@ data:
# LLM catalog discovery sync cron (spec 09 Fase 4). Non-destructive; code
# default off. Interval + plausibility floors keep their code defaults.
LLM_CATALOG_SYNC_CRON_ENABLED: "true"
- CONTROL_API_CODEX_SUBSCRIPTION_ENABLED: "false"
- CODEX_LLM_PROXY_EXECUTION_ENABLED: "false"
---
apiVersion: v1
kind: ConfigMap
diff --git a/deploy/base/control-plane/networkpolicies.yaml b/deploy/base/control-plane/networkpolicies.yaml
index acc345ad4..dd326cb43 100644
--- a/deploy/base/control-plane/networkpolicies.yaml
+++ b/deploy/base/control-plane/networkpolicies.yaml
@@ -422,6 +422,9 @@ spec:
podSelector:
matchLabels:
app: rpc-proxy
+ - podSelector:
+ matchLabels:
+ app: codex-llm-proxy
ports:
- port: 8090
protocol: TCP
@@ -784,3 +787,85 @@ spec:
ports:
- port: 8086
protocol: TCP
+---
+# Codex LLM proxy: runtime from eligible mcp-host pods, admin from Control API,
+# metrics from monitoring. No sibling or namespace-wide ingress.
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+ name: codex-llm-proxy-ingress
+ namespace: control-plane
+ labels:
+ clerum.io/policy-type: service
+spec:
+ podSelector:
+ matchLabels:
+ app: codex-llm-proxy
+ policyTypes:
+ - Ingress
+ ingress:
+ - from:
+ - namespaceSelector:
+ matchLabels:
+ kubernetes.io/metadata.name: mcp-host
+ podSelector:
+ matchLabels:
+ clerum.io/managed-by: host-context-controller
+ - namespaceSelector:
+ matchLabels:
+ kubernetes.io/metadata.name: sandbox-recipes
+ podSelector:
+ matchLabels:
+ clerum.io/managed-by: host-context-controller
+ ports:
+ - port: 8080
+ protocol: TCP
+ - from:
+ - podSelector:
+ matchLabels:
+ app: control-api
+ ports:
+ - port: 8081
+ protocol: TCP
+ - from:
+ - namespaceSelector:
+ matchLabels:
+ kubernetes.io/metadata.name: monitoring
+ ports:
+ - port: 9090
+ protocol: TCP
+---
+# Codex LLM proxy egress: DNS is inherited from allow-dns-egress-control-plane.
+# This policy adds only the RPC gateway redeem/finalize hop and public HTTPS
+# with the canonical private/special-use exclusions. Direct Control API,
+# Postgres, Kubernetes API, metadata, HCC/WRC, and sibling hops stay denied.
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+ name: codex-llm-proxy-egress
+ namespace: control-plane
+ labels:
+ clerum.io/policy-type: service
+spec:
+ podSelector:
+ matchLabels:
+ app: codex-llm-proxy
+ policyTypes:
+ - Egress
+ egress:
+ - ports:
+ - port: 8090
+ protocol: TCP
+ to:
+ - podSelector:
+ matchLabels:
+ app: control-api-rpc-gateway
+ - ports:
+ - port: 443
+ protocol: TCP
+ to:
+ - ipBlock:
+ cidr: 0.0.0.0/0
+ # Filled at deploy time by deploy/base/kustomization.yaml replacements
+ # from PublicEgressExceptionSet. Keep empty here.
+ except: []
diff --git a/deploy/base/kustomization.yaml b/deploy/base/kustomization.yaml
index 8beb8009a..c1f6e4432 100644
--- a/deploy/base/kustomization.yaml
+++ b/deploy/base/kustomization.yaml
@@ -76,3 +76,10 @@ replacements:
name: workflow-recipes-external-egress
fieldPaths:
- spec.egress.*.to.*.ipBlock.except
+ - select:
+ group: networking.k8s.io
+ version: v1
+ kind: NetworkPolicy
+ name: codex-llm-proxy-egress
+ fieldPaths:
+ - spec.egress.*.to.*.ipBlock.except
diff --git a/scripts/e2e/e2e-codex-subscription-network-boundary.sh b/scripts/e2e/e2e-codex-subscription-network-boundary.sh
new file mode 100755
index 000000000..c030a8fbd
--- /dev/null
+++ b/scripts/e2e/e2e-codex-subscription-network-boundary.sh
@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# T2 network-boundary probe for codex-llm-proxy. Fail closed without a
+# verified local owner context. GREEN is captured in Task 23.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+# shellcheck source=../deploy/scripts/lib/clerum-minikube-context.sh
+source "${ROOT}/deploy/scripts/lib/clerum-minikube-context.sh"
+
+if [[ -z "${KUBECONTEXT:-}" ]]; then
+ echo "codex_proxy_boundary: missing KUBECONTEXT" >&2
+ exit 2
+fi
+export CONTEXT="$KUBECONTEXT"
+if ! is_clerum_minikube_context; then
+ echo "codex_proxy_boundary: refusing non-local context ${KUBECONTEXT}" >&2
+ exit 2
+fi
+
+KUBECTL=(kubectl --context "$KUBECONTEXT")
+
+if ! "${KUBECTL[@]}" get ns control-plane >/dev/null 2>&1; then
+ echo "codex_proxy_boundary: workload_missing" >&2
+ exit 3
+fi
+if ! "${KUBECTL[@]}" get deploy -n control-plane codex-llm-proxy >/dev/null 2>&1; then
+ echo "codex_proxy_boundary: workload_missing" >&2
+ exit 3
+fi
+if ! "${KUBECTL[@]}" get networkpolicy -n control-plane codex-llm-proxy-ingress >/dev/null 2>&1; then
+ echo "codex_proxy_boundary: policy_missing" >&2
+ exit 3
+fi
+if ! "${KUBECTL[@]}" get networkpolicy -n control-plane codex-llm-proxy-egress >/dev/null 2>&1; then
+ echo "codex_proxy_boundary: policy_missing" >&2
+ exit 3
+fi
+
+if [[ "${CODEX_NETWORK_BOUNDARY_LIVE:-0}" != "1" ]]; then
+ echo "codex_proxy_boundary: workload and policies present (set CODEX_NETWORK_BOUNDARY_LIVE=1 for runtime probes)"
+ exit 0
+fi
+
+probe_from_proxy() {
+ "${KUBECTL[@]}" exec -n control-plane deploy/codex-llm-proxy -- node "$@"
+}
+
+probe_from_proxy -e 'require("dns").lookup("kubernetes.default.svc.cluster.local", (err) => { if (err) { console.error(err.code || err.message); process.exit(1); } process.exit(0); });'
+echo "codex_proxy_boundary: DNS resolved"
+
+gateway_result="$(probe_from_proxy -e '
+const http = require("http");
+const req = http.get("http://control-api-rpc-gateway.control-plane.svc.cluster.local:8090/", { timeout: 3000 }, (res) => {
+ res.resume();
+ process.stdout.write("reachable:" + res.statusCode);
+ process.exit(0);
+});
+req.on("timeout", () => { req.destroy(); process.stdout.write("timeout"); process.exit(2); });
+req.on("error", (err) => {
+ if (err && err.code === "ECONNREFUSED") { process.stdout.write("reachable:refused"); process.exit(0); }
+ process.stdout.write(String((err && err.code) || err.message));
+ process.exit(1);
+});
+')"
+if [[ "$gateway_result" != reachable:* ]]; then
+ echo "codex_proxy_boundary: rpc-gateway hop blocked (${gateway_result})" >&2
+ exit 1
+fi
+echo "codex_proxy_boundary: rpc-gateway hop reachable"
+
+expect_blocked() {
+ local name="$1"
+ local url="$2"
+ local result
+ result="$(probe_from_proxy -e '
+const http = require("http");
+const https = require("https");
+const target = new URL(process.argv[1]);
+const lib = target.protocol === "https:" ? https : http;
+const req = lib.request(target, { method: "GET", timeout: 3000, rejectUnauthorized: false }, (res) => {
+ res.resume();
+ process.stdout.write("reachable:" + res.statusCode);
+ process.exit(0);
+});
+req.on("timeout", () => { req.destroy(); process.stdout.write("blocked:timeout"); process.exit(0); });
+req.on("error", (err) => {
+ const code = (err && err.code) || "";
+ if (code === "ETIMEDOUT" || code === "EHOSTUNREACH" || code === "ENETUNREACH") {
+ process.stdout.write("blocked:" + code);
+ process.exit(0);
+ }
+ if (code === "ECONNREFUSED") {
+ process.stdout.write("reachable:refused");
+ process.exit(0);
+ }
+ process.stdout.write(String(code || err.message));
+ process.exit(1);
+});
+req.end();
+' "$url")"
+ if [[ "$result" != blocked:* ]]; then
+ echo "codex_proxy_boundary: ${name} should be blocked (${result})" >&2
+ exit 1
+ fi
+ echo "codex_proxy_boundary: ${name} blocked"
+}
+
+expect_blocked "direct_control_api" "http://control-api.control-plane.svc.cluster.local:8090/health"
+expect_blocked "postgres" "http://control-postgres.control-plane.svc.cluster.local:5432/"
+expect_blocked "metadata" "http://169.254.169.254/"
+expect_blocked "host_context_controller" "http://host-context-controller.control-plane.svc.cluster.local:8080/"
+expect_blocked "workflow_recipes" "http://workflow-recipes.control-plane.svc.cluster.local:8080/"
+expect_blocked "kubernetes_api" "https://kubernetes.default.svc.cluster.local/"
+
+if [[ -n "${CODEX_UPSTREAM_FIXTURE_URL:-}" ]]; then
+ fixture_result="$(probe_from_proxy -e '
+const https = require("https");
+const http = require("http");
+const target = new URL(process.argv[1]);
+const lib = target.protocol === "https:" ? https : http;
+const req = lib.request(target, { method: "GET", timeout: 5000, rejectUnauthorized: false }, (res) => {
+ res.resume();
+ process.stdout.write("reachable:" + res.statusCode);
+ process.exit(0);
+});
+req.on("timeout", () => { req.destroy(); process.stdout.write("timeout"); process.exit(2); });
+req.on("error", (err) => {
+ if (err && err.code === "ECONNREFUSED") { process.stdout.write("reachable:refused"); process.exit(0); }
+ process.stdout.write(String((err && err.code) || err.message));
+ process.exit(1);
+});
+req.end();
+' "$CODEX_UPSTREAM_FIXTURE_URL")"
+ if [[ "$fixture_result" != reachable:* ]]; then
+ echo "codex_proxy_boundary: approved upstream fixture blocked (${fixture_result})" >&2
+ exit 1
+ fi
+ echo "codex_proxy_boundary: approved upstream fixture reachable"
+fi
+
+echo "codex_proxy_boundary: live probes passed"
diff --git a/scripts/tests/test-lint-networkpolicies.sh b/scripts/tests/test-lint-networkpolicies.sh
index 3153dd5dd..3a875cf07 100755
--- a/scripts/tests/test-lint-networkpolicies.sh
+++ b/scripts/tests/test-lint-networkpolicies.sh
@@ -218,3 +218,72 @@ RUBYOPT=--disable=gems ruby -ryaml -e '
abort("sandbox-ui static slice must render renamed baseline policies: #{missing.join(", ")}") unless missing.empty?
' "${MINIKUBE_RENDERED}"
echo "PASS: minikube sandbox-ui static policies do not take HCC-owned deny-all/DNS ownership and retain kube-dns-only DNS egress"
+
+RUBYOPT=--disable=gems ruby -ryaml -e '
+ ingress = nil
+ egress = nil
+ YAML.load_stream(File.read(ARGV.fetch(0))) do |doc|
+ next unless doc.is_a?(Hash) && doc["kind"] == "NetworkPolicy"
+ next unless doc.dig("metadata", "namespace") == "control-plane"
+ case doc.dig("metadata", "name")
+ when "codex-llm-proxy-ingress" then ingress = doc
+ when "codex-llm-proxy-egress" then egress = doc
+ end
+ end
+ abort("rendered overlay is missing codex-llm-proxy-ingress") unless ingress
+ abort("rendered overlay is missing codex-llm-proxy-egress") unless egress
+
+ ingress_ports = Array(ingress.dig("spec", "ingress")).flat_map { |rule| Array(rule["ports"]).map { |port| port["port"] } }
+ abort("codex-llm-proxy-ingress must expose 8080/8081/9090") unless ([8080, 8081, 9090] - ingress_ports).empty?
+
+ Array(ingress.dig("spec", "ingress")).each_with_index do |rule, rule_idx|
+ abort("codex-llm-proxy-ingress[#{rule_idx}] must declare from") if Array(rule["from"]).empty?
+ Array(rule["from"]).each do |peer|
+ abort("codex-llm-proxy-ingress must not use a namespace-wide selector") if peer == { "namespaceSelector" => {} } || peer == { "podSelector" => {} }
+ end
+ end
+
+ forbidden_apps = %w[control-api control-postgres host-context-controller workflow-recipes mcp-host]
+ saw_gateway = false
+ saw_public = false
+ Array(egress.dig("spec", "egress")).each_with_index do |rule, rule_idx|
+ Array(rule["to"]).each do |peer|
+ app = peer.dig("podSelector", "matchLabels", "app")
+ abort("codex-llm-proxy-egress[#{rule_idx}] must not allow #{app}") if forbidden_apps.include?(app)
+ saw_gateway = true if app == "control-api-rpc-gateway"
+ ip = peer.dig("ipBlock", "cidr")
+ next unless ip == "0.0.0.0/0"
+ saw_public = true
+ excepts = Array(peer.dig("ipBlock", "except"))
+ abort("codex-llm-proxy-egress public HTTPS is missing private-range exceptions") if excepts.empty?
+ abort("codex-llm-proxy-egress public HTTPS is missing metadata exception") unless excepts.include?("169.254.0.0/16")
+ end
+ end
+ abort("codex-llm-proxy-egress must allow control-api-rpc-gateway") unless saw_gateway
+ abort("codex-llm-proxy-egress must allow public HTTPS with exceptions") unless saw_public
+' "${MINIKUBE_RENDERED}"
+echo "PASS: rendered Codex proxy NetworkPolicies stay narrowly scoped"
+
+BROAD_RENDERED="${TMP_DIR}/minikube-rendered-broad-proxy.yaml"
+RUBYOPT=--disable=gems ruby -ryaml -e '
+ docs = []
+ YAML.load_stream(File.read(ARGV.fetch(0))) do |doc|
+ next unless doc.is_a?(Hash)
+ if doc["kind"] == "NetworkPolicy" && doc.dig("metadata", "name") == "codex-llm-proxy-egress"
+ doc["spec"] ||= {}
+ doc["spec"]["egress"] ||= []
+ doc["spec"]["egress"] << {
+ "ports" => [{ "port" => 443, "protocol" => "TCP" }],
+ "to" => [{ "ipBlock" => { "cidr" => "0.0.0.0/0" } }]
+ }
+ end
+ docs << doc
+ end
+ File.write(ARGV.fetch(1), docs.map { |doc| YAML.dump(doc) }.join("---\n"))
+' "${MINIKUBE_RENDERED}" "${BROAD_RENDERED}"
+if run_lint "${BROAD_RENDERED}" >/tmp/lint-netpol-codex-broad.out 2>&1; then
+ echo "FAIL: Codex proxy broad public egress without exceptions should fail" >&2
+ exit 1
+fi
+grep -q "without public-only exceptions" /tmp/lint-netpol-codex-broad.out
+echo "PASS: lint-networkpolicies rejects a broad Codex proxy egress mutation"
diff --git a/scripts/tests/test-verify-networkpolicies.sh b/scripts/tests/test-verify-networkpolicies.sh
index b77e514ca..a47bddabf 100755
--- a/scripts/tests/test-verify-networkpolicies.sh
+++ b/scripts/tests/test-verify-networkpolicies.sh
@@ -16,7 +16,7 @@ if [[ "${1:-}" == "--context" ]]; then
fi
if [[ "${1:-}" == "kustomize" ]]; then
- cidr="203.0.113.10/32"
+ cidr="198.51.100.10/32"
if [[ "${mode}" == "forbidden" ]]; then
cidr="10.109.0.1/32"
fi
@@ -71,7 +71,7 @@ if [[ "${1:-}" == "get" && "${2:-}" == "networkpolicy" ]]; then
printf '{"items":[]}\n'
exit 0
fi
- cidr="203.0.113.10/32"
+ cidr="198.51.100.10/32"
if [[ "${mode}" == "drift" ]]; then
cidr="35.199.192.1/32"
fi
@@ -150,3 +150,9 @@ if run_case forbidden >/tmp/verify-netpol-forbidden.out 2>&1; then
fi
grep -q "forbidden CIDR" /tmp/verify-netpol-forbidden.out
echo "PASS: verify-networkpolicies fails on forbidden CIDR"
+
+grep -q 'name: codex-llm-proxy-ingress' "${ROOT}/deploy/base/control-plane/networkpolicies.yaml"
+grep -q 'name: codex-llm-proxy-egress' "${ROOT}/deploy/base/control-plane/networkpolicies.yaml"
+grep -A20 'name: control-api-rpc-gateway' "${ROOT}/deploy/base/control-plane/networkpolicies.yaml" \
+ | grep -q 'app: codex-llm-proxy'
+echo "PASS: Codex proxy NetworkPolicies are declared and the RPC gateway admits the proxy"
diff --git a/tests/e2e/fixtures/codex-subscription/compromised-proxy-probe.yaml b/tests/e2e/fixtures/codex-subscription/compromised-proxy-probe.yaml
new file mode 100644
index 000000000..043f9320c
--- /dev/null
+++ b/tests/e2e/fixtures/codex-subscription/compromised-proxy-probe.yaml
@@ -0,0 +1,44 @@
+# Applied only by the Task 23/25 network-boundary rehearsal. Distinct labels
+# keep this Job off the codex-llm-proxy Service. It must not ship credentials
+# or a ServiceAccount token.
+apiVersion: batch/v1
+kind: Job
+metadata:
+ name: codex-compromised-proxy-probe
+ namespace: control-plane
+ labels:
+ app: codex-compromised-proxy-probe
+ clerum.io/test-only: 'true'
+spec:
+ ttlSecondsAfterFinished: 120
+ backoffLimit: 0
+ template:
+ metadata:
+ labels:
+ app: codex-compromised-proxy-probe
+ clerum.io/test-only: 'true'
+ spec:
+ automountServiceAccountToken: false
+ restartPolicy: Never
+ containers:
+ - name: probe
+ image: busybox:1.36
+ command: ['/bin/sh', '-c']
+ args:
+ - |
+ set +e
+ echo "probe start"
+ wget -qO- --timeout=3 http://control-api.control-plane.svc.cluster.local:8090/health
+ echo "direct_control_api:$?"
+ wget -qO- --timeout=3 http://control-postgres.control-plane.svc.cluster.local:5432
+ echo "postgres:$?"
+ wget -qO- --timeout=3 http://169.254.169.254/
+ echo "metadata:$?"
+ echo "probe done"
+ securityContext:
+ allowPrivilegeEscalation: false
+ readOnlyRootFilesystem: true
+ runAsNonRoot: true
+ runAsUser: 65532
+ capabilities:
+ drop: ['ALL']
diff --git a/tests/e2e/fixtures/package-lock.json b/tests/e2e/fixtures/package-lock.json
index 1351408d8..09017c09c 100644
--- a/tests/e2e/fixtures/package-lock.json
+++ b/tests/e2e/fixtures/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "@clerum/e2e-test-fixtures",
- "version": "1.0.60",
+ "version": "1.0.61",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@clerum/e2e-test-fixtures",
- "version": "1.0.60",
+ "version": "1.0.61",
"dependencies": {
"@kubernetes/client-node": "^1.0.0"
},
diff --git a/tests/e2e/fixtures/package.json b/tests/e2e/fixtures/package.json
index fa746f65f..c73d826e5 100644
--- a/tests/e2e/fixtures/package.json
+++ b/tests/e2e/fixtures/package.json
@@ -1,6 +1,6 @@
{
"name": "@clerum/e2e-test-fixtures",
- "version": "1.0.60",
+ "version": "1.0.61",
"description": "E2E test fixtures and utilities for Clerum testing",
"type": "module",
"main": "index.ts",
diff --git a/tests/e2e/integration/network-policies.test.ts b/tests/e2e/integration/network-policies.test.ts
index 73e9eddce..6c6868708 100644
--- a/tests/e2e/integration/network-policies.test.ts
+++ b/tests/e2e/integration/network-policies.test.ts
@@ -10,6 +10,7 @@
*/
import { beforeAll, describe, expect, it } from 'vitest'
import { execFileSync } from 'child_process'
+import { readFileSync } from 'node:fs'
// Short timeout for negative tests — we expect these to time out
const NP_TIMEOUT = 3
@@ -178,6 +179,35 @@ function testConnectivity(
}
}
+describe('Codex LLM proxy NetworkPolicy contract (static)', () => {
+ const policyPath = new URL(
+ '../../../deploy/base/control-plane/networkpolicies.yaml',
+ import.meta.url
+ )
+ const rendered = readFileSync(policyPath, 'utf8')
+
+ it('allows runtime ingress only from eligible mcp-host pods and admin only from Control API', () => {
+ expect(rendered).toContain('name: codex-llm-proxy-ingress')
+ expect(rendered).toContain('name: codex-llm-proxy-egress')
+ expect(rendered).toMatch(/port: 8080[\s\S]*clerum.io\/managed-by: host-context-controller/)
+ expect(rendered).toMatch(/app: control-api[\s\S]*port: 8081/)
+ expect(rendered).toContain('kubernetes.io/metadata.name: monitoring')
+ expect(rendered).not.toMatch(/codex-llm-proxy-ingress[\s\S]*namespaceSelector: \{\}/)
+ })
+
+ it('allows gateway and public HTTPS egress while omitting private and sibling hops', () => {
+ const egress = rendered.slice(rendered.indexOf('name: codex-llm-proxy-egress'))
+ expect(egress).toContain('app: control-api-rpc-gateway')
+ expect(egress).toContain('cidr: 0.0.0.0/0')
+ expect(egress).toContain('except: []')
+ expect(egress).not.toContain('app: control-api\n')
+ expect(egress).not.toContain('app: control-postgres')
+ expect(egress).not.toContain('app: host-context-controller')
+ expect(egress).not.toContain('app: workflow-recipes')
+ expect(egress).not.toContain('app: mcp-host')
+ })
+})
+
describe('NetworkPolicy Enforcement (Calico)', () => {
beforeAll(() => {
clusterReachable = probeClusterReachable()
@@ -213,6 +243,17 @@ describe('NetworkPolicy Enforcement (Calico)', () => {
expect(pods).toContain('Running')
})
+ it('codex-llm-proxy ingress and egress policies exist', ctx => {
+ if (!clusterReachable) ctx.skip()
+ const nps = execFileSync(
+ 'kubectl',
+ ['get', 'networkpolicy', '-n', 'control-plane', '--no-headers'],
+ { encoding: 'utf-8' }
+ )
+ expect(nps).toContain('codex-llm-proxy-ingress')
+ expect(nps).toContain('codex-llm-proxy-egress')
+ })
+
it('deny-all policies exist in secured namespaces', ctx => {
if (!clusterReachable) ctx.skip()
const namespaces = ['mcp-host', 'mcp-server', 'rpc-proxy', 'sandbox-recipes']
diff --git a/tests/e2e/package-lock.json b/tests/e2e/package-lock.json
index 8b6c35470..2b05ec0ef 100644
--- a/tests/e2e/package-lock.json
+++ b/tests/e2e/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.68",
+ "version": "0.1.69",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "clerum-e2e-tests",
- "version": "0.1.68",
+ "version": "0.1.69",
"devDependencies": {
"@types/jsonwebtoken": "^9.0.10",
"@types/node": "^22.0.0",
diff --git a/tests/e2e/package.json b/tests/e2e/package.json
index b2262ef2a..9f389a828 100644
--- a/tests/e2e/package.json
+++ b/tests/e2e/package.json
@@ -1,6 +1,6 @@
{
"name": "clerum-e2e-tests",
- "version": "0.1.68",
+ "version": "0.1.69",
"private": true,
"type": "module",
"scripts": {