Files
claude/lib/tests/guardrails-probe.test.sh
T
bchanot 5a98c2c095 fix(guardrails): probe fails closed on budget, redirects and unread bodies; rules lose five false positives and gain seven misses
The probe trusted the plan's Supabase url, followed redirects for free,
crashed on deep JSON and stopped at the first unconfirmed map candidate.
Rules now scope hydrated state to the export chunk, silence dev configs,
UI-suffixed data attributes, GraphQL types and metadata keys, and catch
Go raw strings, triple-quoted f-strings, sql.raw, empty select() and
multi-line hidden inputs; text output is sanitised; per-variant locks.
2026-10-21 00:13:32 +02:00

501 lines
23 KiB
Bash

#!/usr/bin/env bash
# lib/tests/guardrails-probe.test.sh — floor of the /guardrails live probe.
# A throwaway http.server on 127.0.0.1 serves scripted responses; the probe
# runs against it and each verdict is asserted. Nothing leaves the machine.
# The probe sends read-only methods; this suite proves the OPEN/CLOSED logic,
# the --authorized gate, the same-host redirect guard and the request budget.
set -u
ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
PROBE="$ROOT/skills/guardrails/scripts/probe.py"
WORK="$(mktemp -d)"
PASS=0; FAIL=0; SRV=""
cleanup() { [ -n "$SRV" ] && kill "$SRV" 2>/dev/null; rm -rf "$WORK"; }
trap cleanup EXIT
check() { # check <label> <got> <want>
if [ "$2" = "$3" ]; then PASS=$((PASS+1)); echo " PASS $1"
else FAIL=$((FAIL+1)); echo " FAIL $1 (got '$2', want '$3')"; fi
}
# Fixture server: a fixed map of path -> (status, body, headers). Read-only,
# bound to the loopback, on an OS-chosen port it prints on the first line.
cat > "$WORK/server.py" <<'PY'
import json
from http.server import BaseHTTPRequestHandler, HTTPServer
HITS = {"rl": 0}
class H(BaseHTTPRequestHandler):
def log_message(self, *a):
pass
def _send(self, code, body=b"", headers=None):
self.send_response(code)
for k, v in (headers or {}).items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(body)
def do_OPTIONS(self):
origin = self.headers.get("Origin", "")
upper = ("Access-Control-Allow-Origin", "Access-Control-Allow-Credentials")
names = tuple(n.lower() for n in upper) if self.path == "/lower" else upper
self._send(204, b"", {names[0]: origin, names[1]: "true"})
def do_GET(self):
path = self.path.split("?")[0]
if path == "/rest/v1/open_table":
return self._send(200, b'[{"id": 1}]')
if path == "/rest/v1/closed_table":
return self._send(200, b'[]')
if path == "/api/private":
return self._send(200, b"secret")
if path == "/api/guarded":
return self._send(401, b"no")
if path == "/rl":
HITS["rl"] += 1
return self._send(429 if HITS["rl"] > 5 else 200, b"")
if path == "/nolimit":
return self._send(200, b"")
if path == "/":
return self._send(200, b'<html><script src="/app.js"></script>'
b'<script src="/clean.js"></script>'
b'<script src=/inline.js></script>'
b'<script src="/biginline.js"></script>'
b'<script src="/err.js"></script>'
b'<script src="https://cdn.invalid/x.js"></script>'
b'</html>')
if path == "/app.js":
return self._send(200, b"console.log(1);\n//# sourceMappingURL=app.js.map\n")
if path == "/app.js.map":
return self._send(200, b'{"version":3,"sources":["src/app.ts"],"mappings":""}')
if path == "/clean.js":
return self._send(200, b"console.log(2);\n")
if path == "/inline.js":
return self._send(200, b"console.log(3);\n//# sourceMappingURL="
b"data:application/json;base64,eyJ2ZXJzaW9uIjozfQ==\n")
if path == "/biginline.js":
return self._send(200, b"console.log(4);\n//# sourceMappingURL="
b"data:application/json;base64," + b"A" * 20000)
if path == "/err.js":
return self._send(200, b"console.log(5);\n//# sourceMappingURL=err.js.map\n")
if path == "/err.js.map":
return self._send(503, b"")
if path == "/api/session":
return self._send(200, b'{"id": 2, "token": "t", "profile": {"private": false}}',
{"Content-Type": "application/json"})
if path == "/api/clean":
return self._send(200, b'{"id": 7, "name": "Ada", "role": "member"}',
{"Content-Type": "application/json"})
if path == "/embed.js":
return self._send(200, b'var s="//# sourceMappingURL=data:'
b'application/json;base64,"+btoa(m);\n')
if path == "/redir.js":
return self._send(200, b"console.log(6);\n")
if path == "/redir.js.map":
return self._send(302, b"", {"Location": "http://other.invalid/m"})
if path == "/hdr.js":
return self._send(200, b"console.log(7);\n",
{"SourceMap": "/hdr.real.map"})
if path == "/hdr.real.map":
return self._send(200, b'{"version":3,"sources":["a.ts"]}')
if path == "/cmt.js":
return self._send(200, b"console.log(8);\n//# sourceMappingURL="
b"cmt.real.map\n")
if path == "/cmt.real.map":
return self._send(200, b'{"version":3,"sources":["b.ts"]}')
if path == "/offhost.js":
return self._send(200, b"x();\n//# sourceMappingURL="
b"http://other.invalid/o.map\n")
if path == "/badmap.js":
return self._send(200, b"z();\n//# sourceMappingURL=http://[x\n")
if path == "/trunc.js":
return self._send(200, b"a" * 1_000_001)
if path == "/bigmap.js":
return self._send(200, b"y();\n")
if path == "/bigmap.js.map":
return self._send(200, b'{"sources":["c.ts"],"x":"' + b"A" * 1_000_001)
if path == "/api/echo":
bearer = self.headers.get("Authorization", "")
body = b'{"id": 1, "password_hash": "x"}' if bearer else b'{"id": 1}'
return self._send(200, body, {"Content-Type": "application/json"})
if path == "/api/graphql":
return self._send(200, b'{"data": {"users": {"edges": [{"node": '
b'{"passwordHash": "x"}}]}}}',
{"Content-Type": "application/json"})
if path == "/boom":
return self._send(500, b"Traceback (most recent call last):\n"
b' File "app.py", line 12, in handler\n')
if path == "/hop1":
return self._send(302, b"", {"Location": "/hop2"})
if path == "/hop2":
return self._send(302, b"", {"Location": "/hop3"})
if path == "/hop3":
return self._send(200, b'{"ok": true}')
if path == "/rest/v1/deep":
return self._send(200, b"[" * 200000)
if path == "/meta/keys":
return self._send(200, b'{"tokenType": "bearer", "has_password": true, '
b'"token_expires_in": 3600, "password_changed_at": "2026"}',
{"Content-Type": "application/json"})
if path == "/forbidden.js":
return self._send(200, b"f();\n//# sourceMappingURL=forbidden-real.js.map\n")
if path == "/forbidden.js.map":
return self._send(403, b"")
if path == "/forbidden-real.js.map":
return self._send(200, b'{"version":3,"sources":["f.ts"]}')
if path == "/pct.js":
return self._send(200, b"p();\n//# sourceMappingURL=data:"
b"application/json,%7B%22version%22%3A3%7D\n")
if path == "/limited.js":
return self._send(200, b"l();\n")
if path == "/limited.js.map":
return self._send(429, b"")
if path == "/api/me":
return self._send(200, b'{"id": 1, "email": "t@t.io", '
b'"password_hash": "x", "profile": {"api_key": "y"}, '
b'"next_page_token": "abc", "hashtags": []}',
{"Content-Type": "application/json"})
return self._send(404, b"")
srv = HTTPServer(("127.0.0.1", 0), H)
print(srv.server_port, flush=True)
srv.serve_forever()
PY
python3 -B "$WORK/server.py" > "$WORK/port" &
SRV=$!
for _ in $(seq 1 50); do [ -s "$WORK/port" ] && break; sleep 0.1; done
PORT="$(head -1 "$WORK/port")"
if [ -z "$PORT" ]; then echo " FAIL fixture server did not start"; exit 1; fi
BASE="http://127.0.0.1:$PORT"
probe() { python3 -B "$PROBE" "$@"; }
verdict() { printf '%s\n' "$1" | grep -A1 "$2" | grep -oE 'OPEN|CLOSED|SKIPPED|ERROR' | head -1; }
echo "== authorization gate"
cat > "$WORK/plan.json" <<EOF
{"base_url": "$BASE",
"supabase": {"url": "$BASE", "tables": ["open_table", "closed_table"],
"cross_user_paths": ["/rest/v1/open_table"]},
"routes": [{"path": "/api/private"}, {"path": "/api/guarded"},
{"path": "/api/public", "public": true}],
"cors": true}
EOF
probe "$WORK/plan.json" >/dev/null 2>&1
check "refuses without --authorized (exit 2)" "$?" 2
echo "== read-only probes against the fixture"
export GUARDRAILS_ANON_KEY="anon-test-key"
export GUARDRAILS_JWT2="second-user-test-token"
OUT="$(probe --authorized "$WORK/plan.json")"
RC=$?
check "anon read of an open table is OPEN" \
"$(verdict "$OUT" 'anon-read:open_table')" OPEN
check "anon read of a closed table is CLOSED" \
"$(verdict "$OUT" 'anon-read:closed_table')" CLOSED
check "cross-user read returning rows is OPEN" \
"$(verdict "$OUT" 'cross-user:')" OPEN
check "unauth route returning 200 is OPEN" \
"$(verdict "$OUT" 'no-auth:/api/private')" OPEN
check "unauth route returning 401 is CLOSED" \
"$(verdict "$OUT" 'no-auth:/api/guarded')" CLOSED
check "public route is not probed" \
"$(printf '%s\n' "$OUT" | grep -c 'no-auth:/api/public')" 0
check "reflected origin with credentials is OPEN" \
"$(verdict "$OUT" 'cors-reflect')" OPEN
check "a found OPEN verdict exits 1" "$RC" 1
echo "== skips when a secret is absent"
unset GUARDRAILS_ANON_KEY
OUT="$(probe --authorized "$WORK/plan.json")"
check "anon-read skips without the key" \
"$(verdict "$OUT" 'anon-read')" SKIPPED
export GUARDRAILS_ANON_KEY="anon-test-key"
echo "== rate limit"
cat > "$WORK/rl.json" <<EOF
{"base_url": "$BASE", "rate_limit": {"path": "/rl", "count": 10}}
EOF
OUT="$(probe --authorized "$WORK/rl.json")"
check "a route that starts sending 429 is CLOSED" \
"$(verdict "$OUT" 'rate-limit')" CLOSED
cat > "$WORK/nolimit.json" <<EOF
{"base_url": "$BASE", "rate_limit": {"path": "/nolimit", "count": 10}}
EOF
OUT="$(probe --authorized "$WORK/nolimit.json")"
check "a route with no 429 is OPEN" \
"$(verdict "$OUT" 'rate-limit')" OPEN
echo "== budget caps the burst"
cat > "$WORK/burst.json" <<EOF
{"base_url": "$BASE", "rate_limit": {"path": "/nolimit", "count": 99}}
EOF
OUT="$(probe --authorized "$WORK/burst.json")"
check "the burst is capped, never 99 requests" \
"$(printf '%s\n' "$OUT" | grep -oE 'sent [0-9]+' | grep -oE '[0-9]+')" 25
echo "== usage errors"
probe --authorized "$WORK/missing.json" >/dev/null 2>&1
check "a missing plan exits 2" "$?" 2
printf '{"base_url": "%s", "rate_limit": {"path": "/x", "method": "DELETE"}}\n' \
"$BASE" > "$WORK/bad.json"
probe --authorized "$WORK/bad.json" >/dev/null 2>&1
check "a write method in the plan exits 2" "$?" 2
echo "== exposure probes"
cat > "$WORK/exposure.json" <<EOF
{"base_url": "$BASE",
"routes": [{"path": "/api/me"}, {"path": "/api/guarded"}, {"path": "/api/private"},
{"path": "/api/session"}, {"path": "/api/clean"}],
"exposure": {"error_routes": ["/boom"]}}
EOF
OUT="$(probe --authorized "$WORK/exposure.json")"
check "a served source map is OPEN" \
"$(verdict "$OUT" 'sourcemap:/app.js')" OPEN
check "an inline data: source map is OPEN" \
"$(verdict "$OUT" 'sourcemap:/inline.js')" OPEN
check "a large inline source map is OPEN" \
"$(verdict "$OUT" 'sourcemap:/biginline.js')" OPEN
check "a script with no map is CLOSED" \
"$(verdict "$OUT" 'sourcemap:/clean.js')" CLOSED
check "a foreign-host script is never probed" \
"$(printf '%s\n' "$OUT" | grep -c 'cdn.invalid')" 0
check "a traceback in an error body is OPEN" \
"$(verdict "$OUT" 'error-body:/boom')" OPEN
check "the random 404 path is CLOSED" \
"$(verdict "$OUT" 'error-body:/guardrails-probe-')" CLOSED
check "sensitive keys in a JSON response are OPEN" \
"$(verdict "$OUT" 'fields:/api/me')" OPEN
check "the sensitive key names are listed, never the values" \
"$(printf '%s\n' "$OUT" | grep -A1 'fields:/api/me' | grep -c 'api_key, password_hash$')" 1
check "a bare token key is OPEN, a bare private key is not" \
"$(verdict "$OUT" 'fields:/api/session')" OPEN
check "the session key list is token only" \
"$(printf '%s\n' "$OUT" | grep -A1 'fields:/api/session' | grep -c 'token$')" 1
check "a clean JSON response is CLOSED" \
"$(verdict "$OUT" 'fields:/api/clean')" CLOSED
check "a 503 map answer is SKIPPED" \
"$(verdict "$OUT" 'sourcemap:/err.js')" SKIPPED
check "fields on a 401 is SKIPPED, never CLOSED" \
"$(verdict "$OUT" 'fields:/api/guarded')" SKIPPED
check "fields on a non-JSON body is SKIPPED" \
"$(verdict "$OUT" 'fields:/api/private')" SKIPPED
cat > "$WORK/unreachable.json" <<EOF
{"base_url": "http://127.0.0.1:1", "exposure": {}}
EOF
OUT="$(probe --authorized "$WORK/unreachable.json")"
check "an unreachable base page gives a SKIPPED sourcemap row" \
"$(verdict "$OUT" 'sourcemap')" SKIPPED
printf '{"base_url": "%s", "exposure": {"error_routes": ["boom"]}}\n' "$BASE" > "$WORK/badexp.json"
probe --authorized "$WORK/badexp.json" >/dev/null 2>&1
check "an error route not starting with / exits 2" "$?" 2
printf '{"base_url": "%s", "exposure": []}\n' "$BASE" > "$WORK/badexp2.json"
probe --authorized "$WORK/badexp2.json" >/dev/null 2>&1
check "a non-object exposure block exits 2" "$?" 2
printf '{"base_url": "%s", "exposure": {"scripts": "/app.js"}}\n' "$BASE" > "$WORK/badexp3.json"
probe --authorized "$WORK/badexp3.json" >/dev/null 2>&1
check "a scripts string instead of a list exits 2" "$?" 2
printf '{"base_url": "%s", "routes": [{"path": ".evil.invalid/x"}]}\n' "$BASE" > "$WORK/badroute.json"
probe --authorized "$WORK/badroute.json" >/dev/null 2>&1
check "a route path that could leave the host exits 2" "$?" 2
printf '{"base_url": "%s", "routes": ["/x"]}\n' "$BASE" > "$WORK/badroute2.json"
probe --authorized "$WORK/badroute2.json" >/dev/null 2>&1
check "a route that is not an object exits 2" "$?" 2
printf '{"base_url": "%s", "exposure": true}\n' "$BASE" > "$WORK/badexp4.json"
probe --authorized "$WORK/badexp4.json" >/dev/null 2>&1
check "a boolean exposure block exits 2 without a traceback" "$?" 2
printf '{"base_url": "%s", "exposure": {"scripts": ["/does-not-exist.js"]}}\n' "$BASE" > "$WORK/stale.json"
OUT="$(probe --authorized "$WORK/stale.json")"
check "a listed script that answers 404 is SKIPPED, never CLOSED" \
"$(verdict "$OUT" 'sourcemap:/does-not-exist.js')" SKIPPED
printf '{"base_url": "%s", "exposure": {"scripts": []}}\n' "$BASE" > "$WORK/noscript.json"
OUT="$(probe --authorized "$WORK/noscript.json")"
check "an empty scripts list still gives a SKIPPED sourcemap row" \
"$(verdict "$OUT" 'sourcemap')" SKIPPED
printf '{"base_url": "%s", "rate_limit": null}\n' "$BASE" > "$WORK/badrl.json"
probe --authorized "$WORK/badrl.json" >/dev/null 2>&1
check "a null rate_limit exits 2" "$?" 2
printf '{"base_url": "%s", "routes": 5}\n' "$BASE" > "$WORK/badroutes.json"
probe --authorized "$WORK/badroutes.json" >/dev/null 2>&1
check "a non-list routes exits 2" "$?" 2
printf '{"base_url": "%s", "supabase": {"url": "%s", "cross_user_paths": "/x"}}\n' \
"$BASE" "$BASE" > "$WORK/badcu.json"
probe --authorized "$WORK/badcu.json" >/dev/null 2>&1
check "a string cross_user_paths exits 2" "$?" 2
printf '{"base_url": "%s", "supabase": 5}\n' "$BASE" > "$WORK/badsb.json"
probe --authorized "$WORK/badsb.json" >/dev/null 2>&1
check "a non-object supabase block exits 2" "$?" 2
cat > "$WORK/lower.json" <<EOF
{"base_url": "$BASE", "cors": true, "cors_path": "/lower"}
EOF
OUT="$(probe --authorized "$WORK/lower.json")"
check "lowercase CORS header names are still read" \
"$(verdict "$OUT" 'cors-reflect')" OPEN
echo "== exposure probes: map channels and fail-closed paths"
cat > "$WORK/maps.json" <<EOF
{"base_url": "$BASE",
"exposure": {"scripts": ["/embed.js", "/redir.js", "/hdr.js", "/cmt.js",
"/offhost.js", "/trunc.js", "/bigmap.js", "/badmap.js"], "error_routes": []}}
EOF
OUT="$(probe --authorized "$WORK/maps.json")"
check "a sourceMappingURL string inside code is CLOSED, not an inline map" \
"$(verdict "$OUT" 'sourcemap:/embed.js')" CLOSED
check "a map that redirects off host is SKIPPED, never CLOSED" \
"$(verdict "$OUT" 'sourcemap:/redir.js')" SKIPPED
check "a map named by the SourceMap header is OPEN" \
"$(verdict "$OUT" 'sourcemap:/hdr.js')" OPEN
check "a map named by the trailing comment is OPEN" \
"$(verdict "$OUT" 'sourcemap:/cmt.js')" OPEN
check "a map url on another host is SKIPPED" \
"$(verdict "$OUT" 'sourcemap:/offhost.js')" SKIPPED
check "a malformed map url is SKIPPED, no traceback" \
"$(verdict "$OUT" 'sourcemap:/badmap.js')" SKIPPED
check "the message line keeps its newline and 11-space indent" \
"$(printf '%s\n' "$OUT" | grep -A1 'sourcemap:/offhost.js' | tail -1 | grep -c '^ [^ ]')" 1
check "a truncated script is SKIPPED" \
"$(verdict "$OUT" 'sourcemap:/trunc.js')" SKIPPED
check "an oversize map is SKIPPED" \
"$(verdict "$OUT" 'sourcemap:/bigmap.js')" SKIPPED
cat > "$WORK/maps2.json" <<EOF
{"base_url": "$BASE",
"exposure": {"scripts": ["/forbidden.js", "/pct.js", "/limited.js"],
"error_routes": []}}
EOF
OUT="$(probe --authorized "$WORK/maps2.json")"
check "a 403 first candidate does not hide a map the comment names" \
"$(verdict "$OUT" 'sourcemap:/forbidden.js')" OPEN
check "a percent-encoded data: source map is OPEN" \
"$(verdict "$OUT" 'sourcemap:/pct.js')" OPEN
check "a 429 on the only map candidate is SKIPPED, never CLOSED" \
"$(verdict "$OUT" 'sourcemap:/limited.js')" SKIPPED
echo "== fields probe: depth and bearer"
cat > "$WORK/fields.json" <<EOF
{"base_url": "$BASE",
"routes": [{"path": "/api/echo"}, {"path": "/api/graphql"}],
"exposure": {"scripts": [], "error_routes": []}}
EOF
OUT="$(probe --authorized "$WORK/fields.json")"
check "a sensitive key nested past four levels is OPEN" \
"$(verdict "$OUT" 'fields:/api/graphql')" OPEN
check "the fields probe sends the bearer (key seen only with it)" \
"$(verdict "$OUT" 'fields:/api/echo')" OPEN
OUT="$(env -u GUARDRAILS_JWT2 python3 -B "$PROBE" --authorized "$WORK/fields.json")"
check "without the bearer the same route is CLOSED" \
"$(verdict "$OUT" 'fields:/api/echo')" CLOSED
echo "== plan validation and host guard"
printf '{"base_url": "file:///tmp"}\n' > "$WORK/file.json"
probe --authorized "$WORK/file.json" >/dev/null 2>&1
check "a file:// base_url exits 2" "$?" 2
printf '{"base_url": "http://[x"}\n' > "$WORK/v6.json"
probe --authorized "$WORK/v6.json" >/dev/null 2>&1
check "a malformed base_url exits 2" "$?" 2
printf '{"base_url": 5}\n' > "$WORK/num.json"
ERR="$(probe --authorized "$WORK/num.json" 2>&1 >/dev/null)"
check "a non-string base_url exits 2 without a traceback" \
"$(printf '%s\n' "$ERR" | grep -c 'Traceback')" 0
probe --authorized "$WORK/num.json" >/dev/null 2>&1
check "a non-string base_url exits 2" "$?" 2
printf '{"base_url": "%s", "rate_limit": {"count": 5}}\n' "$BASE" > "$WORK/nopath.json"
ERR="$(probe --authorized "$WORK/nopath.json" 2>&1 >/dev/null)"
check "a rate_limit with no path gives a usage message, no traceback" \
"$(printf '%s\n' "$ERR" | grep -c 'rate_limit.path must be a string')" 1
probe --authorized "$WORK/nopath.json" >/dev/null 2>&1
check "a rate_limit with no path exits 2" "$?" 2
printf '{"base_url": "%s", "routes": [{"path": "/a\\u001b[31mb"}]}\n' "$BASE" > "$WORK/ctl.json"
check "a control character in a path is an ERROR row, no traceback" \
"$(probe --authorized "$WORK/ctl.json" 2>&1 | grep -c 'Traceback')" 0
check "control characters of a target never reach the output" \
"$(probe --authorized "$WORK/ctl.json" | LC_ALL=C grep -c "$(printf '\033')")" 0
same_host() { python3 -B -c '
import sys
sys.path.insert(0, sys.argv[1])
import probe
print(bool(probe._same_host(sys.argv[2], sys.argv[3])))' \
"$ROOT/skills/guardrails/scripts" "$1" "$2"; }
check "an https to http move is not the same host" \
"$(same_host https://a.test/x http://a.test/y)" False
check "a different port is not the same host" \
"$(same_host http://a.test/x http://a.test:81/y)" False
check "a same-scheme same-host url is kept" \
"$(same_host http://a.test/x /y)" True
check "an http to https upgrade on the host is kept" \
"$(same_host http://a.test/x https://a.test/y)" True
echo "== supabase plan, rows state, redirect budget, metadata keys"
printf '{"base_url": "%s", "supabase": {"url": "file:///etc/hosts", "tables": ["t"]}}\n' \
"$BASE" > "$WORK/sbfile.json"
ERR="$(probe --authorized "$WORK/sbfile.json" 2>&1 >/dev/null)"
check "a file:// supabase url exits 2" \
"$(probe --authorized "$WORK/sbfile.json" >/dev/null 2>&1; echo $?)" 2
check "the usage error names supabase.url" \
"$(printf '%s\n' "$ERR" | grep -c 'supabase.url must be an http(s) url')" 1
printf '{"base_url": "%s", "supabase": {"tables": ["t"]}}\n' "$BASE" > "$WORK/sbnourl.json"
ERR="$(probe --authorized "$WORK/sbnourl.json" 2>&1 >/dev/null)"
check "tables without a supabase url is a usage error, no traceback" \
"$(printf '%s\n' "$ERR" | grep -c 'Traceback')" 0
check "tables without a supabase url exits 2" \
"$(probe --authorized "$WORK/sbnourl.json" >/dev/null 2>&1; echo $?)" 2
printf '{"base_url": "%s", "supabase": {"url": "%s", "tables": "notes"}}\n' \
"$BASE" "$BASE" > "$WORK/sbstr.json"
check "a string tables exits 2" \
"$(probe --authorized "$WORK/sbstr.json" >/dev/null 2>&1; echo $?)" 2
printf '{"base_url": "%s", "supabase": {"url": "https://a.test/\\u001b[2J", "tables": ["t"]}}\n' \
"$BASE" > "$WORK/sbesc.json"
ERR="$(probe "$WORK/sbesc.json" 2>&1 >/dev/null)"
check "the refusal names the supabase url, control character replaced" \
"$(printf '%s\n' "$ERR" | grep -cF 'and https://a.test/?[2J')" 1
check "no ESC byte reaches the refusal" \
"$(printf '%s\n' "$ERR" | LC_ALL=C grep -c "$(printf '\033')")" 0
cat > "$WORK/deep.json" <<EOF
{"base_url": "$BASE", "supabase": {"url": "$BASE", "tables": ["deep"]}}
EOF
OUT="$(probe --authorized "$WORK/deep.json" 2>"$WORK/deep.err")"
check "a deeply nested rows body is SKIPPED, never CLOSED" \
"$(verdict "$OUT" 'anon-read:deep')" SKIPPED
check "a deeply nested rows body raises no traceback" \
"$(grep -c Traceback "$WORK/deep.err")" 0
cat > "$WORK/cu401.json" <<EOF
{"base_url": "$BASE", "supabase": {"url": "$BASE", "cross_user_paths": ["/api/guarded"]}}
EOF
OUT="$(probe --authorized "$WORK/cu401.json")"
check "a cross-user read refused with 401 stays CLOSED" \
"$(verdict "$OUT" 'cross-user:/api/guarded')" CLOSED
cat > "$WORK/meta.json" <<EOF
{"base_url": "$BASE", "routes": [{"path": "/meta/keys"}],
"exposure": {"scripts": [], "error_routes": []}}
EOF
OUT="$(probe --authorized "$WORK/meta.json")"
check "metadata keys (camelCase and snake) are never sensitive" \
"$(verdict "$OUT" 'fields:/meta/keys')" CLOSED
hops() { python3 -B -c '
import sys
sys.path.insert(0, sys.argv[1])
import probe
base = sys.argv[2]
s = probe.Session()
r = probe.fetch(s, "GET", base + "/hop1")
print(r.status, s.budget == probe.DEFAULT_BUDGET - 3)
s = probe.Session(budget=2)
print(probe.fetch(s, "GET", base + "/hop1").error == probe.BUDGET_EXHAUSTED)
print(probe._route_probe(probe.Session(budget=2), base,
{"path": "/hop1"}).verdict)' \
"$ROOT/skills/guardrails/scripts" "$BASE"; }
check "a redirect chain is charged per hop and exhaustion reads ERROR" \
"$(hops | tr '\n' ' ')" "200 True True ERROR "
echo "== JSON output"
check "json reports the open count" \
"$(probe --authorized --json "$WORK/plan.json" \
| python3 -B -c 'import json,sys; print(json.load(sys.stdin)["open"])')" 4
echo "---"
echo "passed: $PASS failed: $FAIL"
[ "$FAIL" -eq 0 ]