set -euo pipefail

if [[ "${DEBUG:-}" == "1" ]]; then

set -x

usage() {

}

SHOW_REPORT=0

if [[ $# -gt 0 ]]; then

for arg in "$@"; do

case "$arg" in

--show-report)

SHOW_REPORT=1

;;

-h|--help)

usage

exit 0

;;

*)

echo "unknown argument: $arg" >&2

usage >&2

exit 2

;;

esac

done

required() {

}

required curl

required node

required npm

SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)

REPO_ROOT=$(cd "$SCRIPT_DIR/.." && pwd)

BINARY_PATH="${MCPPROXY_BINARY_PATH:-$REPO_ROOT/mcpproxy}"

FIXTURE_PATH="${MCPPROXY_FIXTURE_PATH:-}"

BASE_URL="${MCPPROXY_BASE_URL:-http://127.0.0.1:18080}"

LISTEN="${BASE_URL#http://}"

SWEEP_DIR="$REPO_ROOT/e2e/web-ui-sweep"

ARTIFACT_DIR="${ARTIFACT_DIR:-$REPO_ROOT/tmp/web-smoke-artifacts}"

REPORT_DIR="$ARTIFACT_DIR/playwright-report"

API_KEY="web-sweep-$(node -e 'process.stdout.write(require("crypto").randomBytes(24).toString("hex"))')"

if [[ ${#API_KEY} -lt 32 ]]; then

echo "failed to generate a random API key for the throwaway instance" >&2

exit 1

SWEEP_SERVER_NAME=""

mkdir -p "$ARTIFACT_DIR" "$REPORT_DIR"

if [[ ! -x "$BINARY_PATH" ]]; then

required go

echo "building mcpproxy binary..."

(cd "$REPO_ROOT" && go build -o "$BINARY_PATH" ./cmd/mcpproxy)

TMPDIR_SWEEP=$(mktemp -d)

CONFIG_PATH="$TMPDIR_SWEEP/config.json"

DATA_DIR="$TMPDIR_SWEEP/data"

LOG_PATH="$TMPDIR_SWEEP/mcpproxy.log"

cleanup() {

}

trap cleanup EXIT

SERVERS_JSON="[]"

if [[ -n "$FIXTURE_PATH" ]]; then

if [[ ! -x "$FIXTURE_PATH" ]]; then

echo "MCPPROXY_FIXTURE_PATH is not executable: $FIXTURE_PATH" >&2

exit 1

fi

# The config below is a heredoc, not JSON-encoded output: a path containing a

# quote, a backslash or a newline would silently produce a malformed (or

# subtly different) config rather than an error. Reject it loudly instead of

# taking on a jq/python dependency for a path that is normally boring.

case "$FIXTURE_PATH" in

*'"'* | *\\* | *$'\n'*)

echo "MCPPROXY_FIXTURE_PATH contains a quote, backslash or newline and cannot be embedded in the sweep config: $FIXTURE_PATH" >&2

exit 1

;;

esac

SWEEP_SERVER_NAME="sweep-stdio"

SERVERS_JSON=$(cat <<JSON

cat <<JSON >"$CONFIG_PATH"

HEADLESS=1 DO_NOT_TRACK=1 MCPPROXY_API_KEY="$API_KEY" "$BINARY_PATH" serve \

--config "$CONFIG_PATH" --listen "$LISTEN" >"$LOG_PATH" 2>&1 &

SERVER_PID=$!

echo "mcpproxy started (PID ${SERVER_PID}); waiting for readiness at ${BASE_URL}..."

attempt=0

until curl -s --connect-timeout 2 --max-time 5 -o /dev/null -w '%{http_code}' \

-H "X-API-Key: ${API_KEY}" "$BASE_URL/api/v1/servers" | grep -q '^200$'; do

# Fail fast if the candidate already exited (port in use → exit code 2, bad

# config → 4, DB locked → 3). Without this the loop would burn the full

# timeout, and — worse — a leftover instance of a PREVIOUS sweep listening on

# the same port could answer 200 and the sweep would silently exercise that

# stale binary instead of the candidate.

if ! kill -0 "$SERVER_PID" >/dev/null 2>&1; then

wait "$SERVER_PID" >/dev/null 2>&1 || true

echo "mcpproxy exited before becoming ready at ${BASE_URL} (is ${LISTEN} already in use?)" >&2

cat "$LOG_PATH" >&2

exit 1

fi

sleep 1

attempt=$((attempt + 1))

if [[ $attempt -gt 45 ]]; then

echo "server did not become ready after ${attempt}s" >&2

cat "$LOG_PATH" >&2

exit 1

fi

echo "server ready at $BASE_URL"

export PLAYWRIGHT_BROWSERS_PATH="${PLAYWRIGHT_BROWSERS_PATH:-$REPO_ROOT/tmp/playwright-browsers}"

mkdir -p "$PLAYWRIGHT_BROWSERS_PATH"

lock_hash() {

node -e 'const c=require("crypto"),f=require("fs");process.stdout.write(c.createHash("sha256").update(f.readFileSync(process.argv[1])).digest("hex"))' "$1" 2>/dev/null || true

}

LOCK_STAMP="$SWEEP_DIR/node_modules/.sweep-lock-sha256"

WANT_LOCK_HASH=$(lock_hash "$SWEEP_DIR/package-lock.json")

if [[ -z "$WANT_LOCK_HASH" ]]; then

echo "cannot hash $SWEEP_DIR/package-lock.json — is the lockfile committed?" >&2

exit 1

HAVE_LOCK_HASH=""

if [[ -f "$LOCK_STAMP" ]]; then

HAVE_LOCK_HASH=$(cat "$LOCK_STAMP")

if [[ ! -x "$SWEEP_DIR/node_modules/.bin/playwright" || "$HAVE_LOCK_HASH" != "$WANT_LOCK_HASH" ]]; then

echo "installing the locked @playwright/test into $SWEEP_DIR (npm ci)"

# cd rather than `npm ci --prefix`: --prefix has a long history of version-

# dependent behaviour for `ci` specifically, and this runs during release

# qualification — an install that silently resolves against the repo root

# instead of the sweep's lockfile is not a failure mode worth risking.

(cd "$SWEEP_DIR" && npm ci)

# After npm ci, which wipes node_modules (and with it any previous stamp).

printf '%s' "$WANT_LOCK_HASH" >"$LOCK_STAMP"

echo "@playwright/test already installed from the current lockfile"

PLAYWRIGHT_BIN="$SWEEP_DIR/node_modules/.bin/playwright"

if [[ ! -x "$PLAYWRIGHT_BIN" ]]; then

echo "playwright CLI not found after install" >&2

exit 1

echo "installing Playwright Chromium (cached under $PLAYWRIGHT_BROWSERS_PATH)"

if [[ "$(uname -s)" == "Linux" ]]; then

"$PLAYWRIGHT_BIN" install --with-deps chromium

"$PLAYWRIGHT_BIN" install chromium

set +e

(

cd "$SWEEP_DIR" || exit 1

MCPPROXY_BASE_URL="$BASE_URL" \

MCPPROXY_API_KEY="$API_KEY" \

SWEEP_SERVER_NAME="$SWEEP_SERVER_NAME" \

SWEEP_REPORT_DIR="$REPORT_DIR" \

"$PLAYWRIGHT_BIN" test web-ui-sweep.spec.ts visual-a11y-sweep.spec.ts

)

PLAYWRIGHT_STATUS=$?

set -e

cp "$LOG_PATH" "$ARTIFACT_DIR/server.log"

if [[ $PLAYWRIGHT_STATUS -ne 0 ]]; then

echo "web UI sweep FAILED; artifacts (HTML report + server log) in $ARTIFACT_DIR" >&2

exit $PLAYWRIGHT_STATUS

echo "web UI sweep passed; artifacts stored in $ARTIFACT_DIR"

if [[ $SHOW_REPORT -eq 1 ]]; then

echo "launching Playwright HTML report (Ctrl+C to exit)..."

"$PLAYWRIGHT_BIN" show-report "$REPORT_DIR"

exit 0