Compare commits

..
Author SHA1 Message Date
bsodfather 9567bbf3aa fix(ci): pass the community scope guard and publish release artifacts before registry steps
CI / Rust Checks (pull_request) Canceled after 38m52s
CI / UI Checks (pull_request) Canceled after 0s
Community Release / release (push) Canceled after 38m39s
CI / Frontend E2E (pull_request) Canceled after 0s
CI / Community Image Smoke (pull_request) Canceled after 0s
CI / Deploy (pull_request) Canceled after 0s
- the community scope guard rejected the innocuous English comment 'One timed
  resources/list' in the Story 3.8 discovery diagnostic (its 'one-time-token'
  marker matches any 'one time' phrase). Reword the comment; no behaviour change.
- move the release artifact publication ahead of the registry/OpenBao steps, so a
  credential problem cannot leave the archives, checksums and SBOM unpublished.
2026-10-25 09:27:55 +00:00
bsodfather 54ce770682 feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00
31 changed files with 427 additions and 2628 deletions

No files matched your search

+90 -133
View File
@@ -2,15 +2,6 @@ name: CI
on:
pull_request:
types: [opened, synchronize, reopened, labeled, unlabeled]
workflow_dispatch:
inputs:
validation_level:
description: Validation depth for this run
type: choice
options: [story, feature]
default: story
required: true
push:
branches:
- main
@@ -18,8 +9,6 @@ on:
env:
CARGO_BUILD_JOBS: "2"
CARGO_INCREMENTAL: "0"
CARGO_PROFILE_DEV_DEBUG: "0"
CARGO_PROFILE_TEST_DEBUG: "0"
RUST_TEST_THREADS: "2"
TESTCONTAINERS_RYUK_DISABLED: "true"
@@ -30,7 +19,7 @@ jobs:
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@v5
with:
fetch-depth: 0
@@ -67,6 +56,12 @@ jobs:
docker --version
docker info
- name: Install dependency policy tool
run: cargo install cargo-deny --version 0.20.2 --locked
- name: Run tooling unit tests
run: python3 -m unittest discover -s tests/unit
- name: Check typed runtime configuration contract
run: |
cargo run -p crank-config --bin crank-config-contract -- --check
@@ -109,10 +104,14 @@ jobs:
- name: Check Rust code health
run: scripts/check-rust-code-health.sh
- name: Check dependency licenses and advisories
run: cargo deny --locked check advisories bans licenses sources
- name: Check Rust boundaries
run: scripts/check-rust-boundaries.sh
- name: Run offline OpenAPI support corpus gate
run: cargo test -p crank-import --test corpus -- --test-threads=1
- name: Check OpenAPI matrix and corpus compatibility versions
env:
@@ -128,15 +127,80 @@ jobs:
fi
python3 scripts/check-openapi-matrix-compatibility.py --base "$base_ref"
- name: Run Crank story ATDD
run: scripts/ci-story-checks.sh
- name: Save OpenAPI corpus evidence
if: always()
uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7 # v4
with:
name: openapi-corpus-evidence
path: crates/crank-import/target/openapi-corpus/evidence-*.json
if-no-files-found: warn
- name: Run clippy
run: cargo clippy --workspace --all-targets --all-features --jobs "$CARGO_BUILD_JOBS" -- -D warnings
# One event per change: a feature branch is gated by its pull request, so the push event runs
# only on `main` (see `on:` above). No cache and no parallel test shards are configured on
# purpose: both need a measured runner/isolation check first (team validation policy), and the
# workspace suites already isolate shared databases per test process.
#
# Story events (`pull_request`) run only the packages the diff touches; the full workspace
# suite stays the feature/release gate and runs on `main`.
- name: Run story tests (affected packages)
if: ${{ gitea.event_name == 'pull_request' }}
run: |
set -eu
base="$(git merge-base HEAD origin/main 2>/dev/null || true)"
if [ -z "$base" ]; then
git fetch --no-tags origin main
base="$(git merge-base HEAD FETCH_HEAD)"
fi
changed="$(git diff --name-only "$base" HEAD)"
packages=""
workspace=""
for path in $changed; do
case "$path" in
Cargo.toml|Cargo.lock|rust-toolchain.toml|justfile|vendor/*|crates/Cargo.toml|apps/Cargo.toml)
workspace="yes"
;;
crates/*/*)
packages="$packages $(printf '%s' "$path" | cut -d/ -f2)"
;;
apps/admin-api/*)
packages="$packages admin-api"
;;
apps/mcp-server/*)
packages="$packages mcp-server"
;;
esac
done
if [ -n "$workspace" ]; then
echo "shared build input changed: running the whole workspace"
cargo test --workspace --all-targets --jobs "$CARGO_BUILD_JOBS" -- --test-threads=1
exit 0
fi
selected=""
for package in $(printf '%s\n' $packages | sort -u); do
selected="$selected -p $package"
done
if [ -z "$selected" ]; then
echo "no Rust package changed in this diff; the static checks above are the story gate"
exit 0
fi
echo "story packages:$selected"
cargo test $selected --all-targets --jobs "$CARGO_BUILD_JOBS" -- --test-threads=1
- name: Run full workspace tests (feature/release gate)
if: ${{ gitea.event_name != 'pull_request' }}
run: cargo test --workspace --all-targets --jobs "$CARGO_BUILD_JOBS" -- --test-threads=1
ui:
name: UI Checks
runs-on: ubuntu-latest
needs: rust
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@v5
- name: Verify runner toolchain
run: |
@@ -144,7 +208,6 @@ jobs:
npm --version
docker --version
- name: Install UI dependencies
working-directory: apps/ui
run: npm ci
@@ -157,76 +220,10 @@ jobs:
working-directory: apps/ui
run: npm run build
rust-feature:
needs: rust
name: Rust Feature Validation
if: >-
inputs.validation_level == 'feature' ||
contains(gitea.event.pull_request.labels.*.name, 'feature-ready')
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
with:
fetch-depth: 0
- name: Install Rust toolchain
run: |
set -eu
toolchain="$(sed -n 's/^channel = "\(.*\)"/\1/p' rust-toolchain.toml | head -n1)"
if [ -z "$toolchain" ]; then
echo "Unable to read Rust toolchain channel from rust-toolchain.toml" >&2
exit 1
fi
rustup toolchain install "$toolchain" --profile minimal --component clippy --component rustfmt
rustup default "$toolchain"
host="$(rustc -vV | sed -n 's/^host: //p')"
toolchain_dir="${RUSTUP_HOME:-$HOME/.rustup}/toolchains/${toolchain}-${host}"
toolchain_bin="$toolchain_dir/bin"
if [ ! -x "$toolchain_bin/rustc" ] || [ ! -x "$toolchain_bin/cargo" ]; then
echo "Rust $toolchain was not installed at $toolchain_dir." >&2
exit 1
fi
printf '%s\n' "$toolchain_bin" >> "$GITHUB_PATH"
"$toolchain_bin/rustc" --version
"$toolchain_bin/cargo" --version
"$toolchain_bin/rustfmt" --version
"$toolchain_bin/cargo-clippy" --version
- name: Verify runner toolchain
run: |
python3 --version
rustc --version
cargo --version
rustfmt --version
cargo clippy --version
docker --version
docker info
- name: Install dependency policy tool
run: cargo install cargo-deny --version 0.20.2 --locked
- name: Run tooling unit tests
run: python3 -m unittest discover -s tests/unit
- name: Check dependency licenses and advisories
run: cargo deny --locked check advisories bans licenses sources
- name: Run offline OpenAPI support corpus gate
run: cargo test -p crank-import --test corpus -- --test-threads=1
- name: Save OpenAPI corpus evidence
if: always()
uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7 # v4
with:
name: openapi-corpus-evidence
path: crates/crank-import/target/openapi-corpus/evidence-*.json
if-no-files-found: warn
- name: Run clippy
run: cargo clippy --workspace --all-targets --all-features --jobs "$CARGO_BUILD_JOBS" -- -D warnings
- name: Run tests
run: cargo test --workspace --all-targets --jobs "$CARGO_BUILD_JOBS" -- --test-threads=1
frontend-e2e:
needs: [rust, ui]
if: >-
inputs.validation_level == 'feature' ||
contains(gitea.event.pull_request.labels.*.name, 'feature-ready')
name: Frontend E2E
runs-on: ubuntu-latest
needs: ui
services:
crank-e2e-postgres:
image: postgres:16-alpine
@@ -249,7 +246,7 @@ jobs:
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@v5
- name: Install Rust toolchain
run: |
@@ -327,16 +324,15 @@ jobs:
find .tmp/ui-e2e/logs -maxdepth 1 -type f -print -exec sed -n '1,220p' {} \; || true
deployment:
needs: [rust, ui]
if: >-
inputs.validation_level == 'feature' ||
contains(gitea.event.pull_request.labels.*.name, 'feature-ready')
name: Community Image Smoke
runs-on: ubuntu-latest
needs:
- rust
- ui
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@v5
- name: Validate Community deployment manifests
run: |
@@ -451,53 +447,14 @@ jobs:
docker compose -f deploy/community/docker-compose.images.yml \
--env-file .tmp/community-smoke.env --profile local-db down -v --remove-orphans || true
required-checks:
name: Required Checks
runs-on: ubuntu-latest
if: always()
needs:
- rust
- ui
- deployment
- rust-feature
- frontend-e2e
steps:
- name: Require story gates and mode-appropriate feature gates
env:
FEATURE_VALIDATION: ${{ inputs.validation_level == 'feature' || contains(gitea.event.pull_request.labels.*.name, 'feature-ready') }}
RUST_RESULT: ${{ needs.rust.result }}
UI_RESULT: ${{ needs.ui.result }}
RUST_FEATURE_RESULT: ${{ needs.rust-feature.result }}
E2E_RESULT: ${{ needs.frontend-e2e.result }}
IMAGE_RESULT: ${{ needs.deployment.result }}
run: |
set -eu
if [ "$RUST_RESULT" != "success" ] || \
[ "$UI_RESULT" != "success" ]; then
echo "A required story gate did not succeed." >&2
exit 1
fi
if [ "$FEATURE_VALIDATION" = "true" ]; then
if [ "$RUST_FEATURE_RESULT" != "success" ] || \
[ "$E2E_RESULT" != "success" ] || \
[ "$IMAGE_RESULT" != "success" ]; then
echo "A required feature gate did not succeed." >&2
exit 1
fi
else
if [ "$RUST_FEATURE_RESULT" != "skipped" ] || \
[ "$E2E_RESULT" != "skipped" ] || \
[ "$IMAGE_RESULT" != "skipped" ]; then
echo "A feature-only gate did not skip in story mode." >&2
exit 1
fi
fi
deploy:
name: Deploy
runs-on: ubuntu-latest
needs:
- required-checks
- rust
- ui
- frontend-e2e
- deployment
if: ${{ gitea.event_name == 'push' && gitea.ref == 'refs/heads/main' }}
env:
REGISTRY: git.itexp.me
@@ -509,7 +466,7 @@ jobs:
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
uses: actions/checkout@v5
- name: Verify runner toolchain
run: |
+56 -61
View File
@@ -5,13 +5,6 @@ on:
tags:
- "v*"
workflow_dispatch:
inputs:
validation_level:
description: Validation depth for this run
type: choice
options: [story, feature]
default: story
required: true
env:
REGISTRY: git.itexp.me
@@ -24,17 +17,10 @@ env:
jobs:
release:
runs-on: ubuntu-latest
permissions:
code: read
releases: write
steps:
- name: Checkout
uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
- name: Clear optional release evidence
run: rm -f .tmp/openapi-playwright.json .tmp/openapi-ui-evidence.json
uses: actions/checkout@v5
- name: Use preinstalled Rust toolchain
run: |
@@ -67,14 +53,7 @@ jobs:
- name: Install dependency policy tool
run: cargo install cargo-deny --version 0.20.2 --locked
- name: Check formatting
run: cargo fmt --all --check
- name: Audit Rust dependencies
run: cargo deny --locked check advisories bans licenses sources
- name: Run tooling unit tests
if: inputs.validation_level == 'feature'
run: python3 -m unittest discover -s tests/unit
- name: Check typed runtime configuration contract
@@ -114,19 +93,16 @@ jobs:
- name: Check Community scope
run: scripts/check-community-scope.sh
- name: Run Crank story ATDD
run: scripts/ci-story-checks.sh
- name: Run release quality gates
if: inputs.validation_level == 'feature'
run: |
cargo fmt --all --check
cargo clippy --workspace --all-targets --all-features -- -D warnings
cargo test --workspace --all-targets -- --test-threads=1
cargo deny --locked check advisories bans licenses sources
- name: Build release binaries
run: cargo build --release -p admin-api -p mcp-server
- name: Install UI dependencies
working-directory: apps/ui
run: npm ci
@@ -140,12 +116,10 @@ jobs:
run: npm run build
- name: Install Playwright browser
if: inputs.validation_level == 'feature'
working-directory: apps/ui
run: npx playwright install --with-deps chromium
- name: Run release end-to-end tests
if: inputs.validation_level == 'feature'
working-directory: apps/ui
run: |
mkdir -p ../../.tmp
@@ -153,7 +127,6 @@ jobs:
PLAYWRIGHT_JSON_OUTPUT=../../.tmp/openapi-playwright.json npm run e2e
- name: Collect sanitized OpenAPI UI release evidence
if: inputs.validation_level == 'feature'
working-directory: apps/ui
run: |
trap 'rm -f ../../.tmp/openapi-playwright.json' EXIT
@@ -182,26 +155,22 @@ jobs:
- name: Package release artifacts
run: |
set -euo pipefail
mkdir -p dist/release
source_revision="$(git rev-parse HEAD)"
evidence_artifact="dist/crank-openapi-ui-evidence-${IMAGE_TAG}-${source_revision}.json"
cp target/release/admin-api dist/release/admin-api
cp target/release/crank-migrate dist/release/crank-migrate
cp target/release/mcp-server dist/release/mcp-server
cp .tmp/openapi-ui-evidence.json "$evidence_artifact"
tar -C dist/release -czf dist/crank-community-admin-api-${IMAGE_TAG}.tar.gz admin-api crank-migrate
tar -C dist/release -czf dist/crank-community-mcp-server-${IMAGE_TAG}.tar.gz mcp-server
tar -C apps/ui/dist -czf dist/crank-community-ui-${IMAGE_TAG}.tar.gz .
files=(
"dist/crank-community-admin-api-${IMAGE_TAG}.tar.gz"
"dist/crank-community-mcp-server-${IMAGE_TAG}.tar.gz"
"dist/crank-community-ui-${IMAGE_TAG}.tar.gz"
)
if [ -f .tmp/openapi-ui-evidence.json ]; then
cp .tmp/openapi-ui-evidence.json "$evidence_artifact"
files+=("$evidence_artifact")
fi
sha256sum "${files[@]}" > "dist/crank-community-${IMAGE_TAG}-checksums.txt"
sha256sum \
dist/crank-community-admin-api-${IMAGE_TAG}.tar.gz \
dist/crank-community-mcp-server-${IMAGE_TAG}.tar.gz \
dist/crank-community-ui-${IMAGE_TAG}.tar.gz \
"$evidence_artifact" \
> dist/crank-community-${IMAGE_TAG}-checksums.txt
- name: Generate SBOM
run: |
@@ -209,28 +178,54 @@ jobs:
dir:/workspace -o spdx-json \
> dist/crank-community-${IMAGE_TAG}-sbom.spdx.json
- name: Publish release bundles, checksums, evidence, and SBOM to Gitea
if: startsWith(gitea.ref, 'refs/tags/v')
env:
GITEA_SERVER_URL: ${{ gitea.server_url }}
GITEA_REPOSITORY: ${{ gitea.repository }}
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
RELEASE_TAG: ${{ gitea.ref_name }}
SOURCE_REVISION: ${{ gitea.sha }}
- name: Write release notes
run: |
set -euo pipefail
assets=(
"dist/crank-community-admin-api-${RELEASE_TAG}.tar.gz"
"dist/crank-community-mcp-server-${RELEASE_TAG}.tar.gz"
"dist/crank-community-ui-${RELEASE_TAG}.tar.gz"
"dist/crank-community-${RELEASE_TAG}-checksums.txt"
"dist/crank-community-${RELEASE_TAG}-sbom.spdx.json"
)
evidence="dist/crank-openapi-ui-evidence-${RELEASE_TAG}-${SOURCE_REVISION}.json"
if [ -f "$evidence" ]; then
assets+=("$evidence")
set -eu
tag="${{ gitea.ref_name }}"
{
echo "## Crank Community ${tag}"
echo
echo "Source commit: \`$(git rev-parse HEAD)\`"
echo
echo "### Changes"
echo
git log --oneline -25 | sed 's/^/- /'
echo
echo "### Artifacts and checksums"
echo
echo '```'
cat "dist/crank-community-${tag}-checksums.txt"
echo '```'
} > dist/RELEASE-NOTES.md
cat dist/RELEASE-NOTES.md
# The archives, the checksums and the SBOM only exist inside the runner workspace until they are
# attached to the release entry: publish them so a released version keeps its artifacts, and do
# it before the registry steps so an image-credential problem cannot lose them.
- name: Publish artifacts to the Gitea release
env:
RELEASE_TOKEN: ${{ secrets.GITEA_TOKEN }}
FALLBACK_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
set -eu
tag="${{ gitea.ref_name }}"
token="${RELEASE_TOKEN:-${FALLBACK_TOKEN:-}}"
if [ -z "$token" ]; then
echo "No Gitea token is available to the workflow: the release artifacts stay in the runner workspace" >&2
exit 1
fi
python3 scripts/ci-release-assets.py "${assets[@]}"
prerelease=""
case "$tag" in
*-*) prerelease="--prerelease" ;;
esac
GITEA_TOKEN="$token" python3 scripts/publish-gitea-release.py \
--api "${{ gitea.server_url }}/api/v1" \
--repo "${{ gitea.repository }}" \
--tag "$tag" \
--title "Crank Community ${tag}" \
--notes-file dist/RELEASE-NOTES.md \
--dist dist \
$prerelease
- name: Load deployment secrets from OpenBao
env:
-1
View File
@@ -7,7 +7,6 @@ mod integration {
mod inventory_projection;
mod jsonrpc_correlation;
mod mcp_completion;
mod mcp_logging;
mod mcp_prompts;
mod request_context;
mod revision_matrix;
@@ -1,805 +0,0 @@
//! Story 3.18 acceptance tests: safe MCP server logging (AT-3.18-01..03, FR-19).
//!
//! Oracles: `docs/acceptance-test-plan.md` AT-3.18-01..03, `epics.md` Story 3.18 and the pinned
//! `logging`/`notifications/message`/`LoggingLevel` schemas of both supported revisions
//! (`2026-07-28` carries the level per request in `_meta`; `2025-11-25` serves `logging/setLevel`).
//! Every request travels through the real HTTP endpoint built by `build_test_app` over a real
//! PostgreSQL registry; the level is set through the production request path.
//!
//! The delivered events are observed on the SSE response stream, which is the only carrier the
//! pinned transport gives a server notification: a JSON body has no place for one. Where a pending
//! notification exists and the client offered `text/event-stream`, the negotiated mode is the stream.
//!
//! No external MCP client is exercised here: these are local harness results against the pinned wire
//! shapes, and the story handoff states that honestly.
use std::time::Duration;
use crank_core::PlatformApiKeyScope;
use crank_registry::PostgresRegistry;
use serde_json::{Value, json};
use super::common::{
agent_mcp_url, build_test_app, create_platform_api_key, initialize_session,
publish_agent_with_bindings, spawn_mcp_server, test_registry,
};
const MODERN_REVISION: &str = "2026-07-28";
const LEGACY_REVISION: &str = "2025-11-25";
const META_PROTOCOL_VERSION: &str = "io.modelcontextprotocol/protocolVersion";
const META_LOG_LEVEL: &str = "io.modelcontextprotocol/logLevel";
const META_CLIENT_CAPABILITIES: &str = "io.modelcontextprotocol/clientCapabilities";
const META_CLIENT_INFO: &str = "io.modelcontextprotocol/clientInfo";
const AGENT_SLUG: &str = "logging-agent";
const OTHER_AGENT_SLUG: &str = "logging-other";
/// The one safe wire detail of a malformed logging level.
const INVALID_LEVEL: &str = "invalid logging level";
/// The fixed logger name of a delivered notification.
const LOGGER_NAME: &str = "crank-mcp-server";
/// A value that must never appear in a delivered notification. It is distinctive on purpose.
const CANARY: &str = "crank-canary-9f7620e5-aa41-4b0d";
struct LoggingEndpoint {
client: reqwest::Client,
base_url: String,
api_key: String,
other_api_key: String,
registry: PostgresRegistry,
}
impl LoggingEndpoint {
fn url(&self, agent_slug: &str) -> String {
agent_mcp_url(&self.base_url, agent_slug)
}
/// One request whose response is negotiated as the SSE stream, so a pending notification really
/// has a carrier. The body is split into its notifications and the final JSON-RPC response.
async fn post_stream(
&self,
agent_slug: &str,
api_key: &str,
headers: &[(&str, &str)],
payload: Value,
) -> StreamReply {
let mut request = self
.client
.post(self.url(agent_slug))
.header(reqwest::header::ACCEPT, "text/event-stream")
.header(reqwest::header::AUTHORIZATION, format!("Bearer {api_key}"));
for (name, value) in headers {
request = request.header(*name, *value);
}
let response = request
.json(&payload)
.send()
.await
.expect("the MCP endpoint answers");
let status = response.status();
let content_type = response
.headers()
.get(reqwest::header::CONTENT_TYPE)
.and_then(|value| value.to_str().ok())
.unwrap_or_default()
.to_owned();
let body = response.text().await.expect("the stream body is readable");
StreamReply::parse(status, content_type, body)
}
/// One legacy request inside the initialized session of `agent_slug`.
async fn legacy_post(
&self,
agent_slug: &str,
api_key: &str,
session_id: &str,
payload: Value,
) -> StreamReply {
self.post_stream(
agent_slug,
api_key,
&[
("MCP-Protocol-Version", LEGACY_REVISION),
("MCP-Session-Id", session_id),
],
payload,
)
.await
}
/// One `logging/setLevel` request of the legacy era.
async fn set_level(&self, session_id: &str, level: Value) -> StreamReply {
self.legacy_post(
AGENT_SLUG,
&self.api_key,
session_id,
json!({
"jsonrpc": "2.0",
"id": 41,
"method": "logging/setLevel",
"params": {"level": level}
}),
)
.await
}
/// One modern request of an arbitrary method with the required per-request identity.
async fn modern_stream(&self, method: &str, params: Value) -> StreamReply {
let mut params = params;
params["_meta"] = json!({
META_PROTOCOL_VERSION: MODERN_REVISION,
META_CLIENT_CAPABILITIES: {},
META_CLIENT_INFO: {"name": "crank-logging-atdd", "version": "0.1.0"}
});
self.modern_stream_with_params(method, params).await
}
/// The same, with the caller's `params` (including a chosen `_meta`).
async fn modern_stream_with_params(&self, method: &str, params: Value) -> StreamReply {
self.post_stream(
AGENT_SLUG,
&self.api_key,
&[
("MCP-Protocol-Version", MODERN_REVISION),
("Mcp-Method", method),
],
json!({"jsonrpc": "2.0", "id": 51, "method": method, "params": params}),
)
.await
}
async fn legacy_session(&self, agent_slug: &str, api_key: &str) -> String {
initialize_session(&self.client, &self.url(agent_slug), api_key).await
}
}
struct StreamReply {
status: reqwest::StatusCode,
content_type: String,
/// The JSON-RPC response, which is the last event of the stream.
response: Value,
/// The `notifications/message` bodies delivered before it.
notifications: Vec<Value>,
/// The raw body, so a test can search it for a canary value.
raw: String,
}
impl StreamReply {
/// Parse a reply that may arrive either as an SSE stream (a pending notification needs the
/// stream) or as the plain JSON body of a method this era does not serve.
fn parse(status: reqwest::StatusCode, content_type: String, body: String) -> Self {
let mut messages = Vec::new();
for block in body.split("\n\n") {
for line in block.lines() {
let Some(data) = line.strip_prefix("data:") else {
continue;
};
let data = data.trim_start();
if data.is_empty() {
continue;
}
let value: Value = serde_json::from_str(data)
.unwrap_or_else(|error| panic!("every stream event is JSON: {data:?} {error}"));
messages.push(value);
}
}
if messages.is_empty() {
// An era-correct rejection of an unserved method is answered as a plain JSON body: it
// never carries a notification, so there is nothing to stream.
let response: Value = serde_json::from_str(&body)
.unwrap_or_else(|error| panic!("expected a JSON-RPC body, got {body:?}: {error}"));
return Self {
status,
content_type,
response,
notifications: Vec::new(),
raw: body,
};
}
let response = messages
.pop()
.unwrap_or_else(|| panic!("the stream must end with the JSON-RPC response: {body:?}"));
Self {
status,
content_type,
response,
notifications: messages,
raw: body,
}
}
fn result(&self) -> &Value {
self.response
.get("result")
.unwrap_or_else(|| panic!("expected a JSON-RPC result, got {}", self.response))
}
fn error(&self) -> (i64, String) {
let code = self
.response
.pointer("/error/code")
.and_then(Value::as_i64)
.unwrap_or_else(|| panic!("expected a JSON-RPC error, got {}", self.response));
let message = self
.response
.pointer("/error/message")
.and_then(Value::as_str)
.unwrap_or_default()
.to_owned();
(code, message)
}
fn assert_stream(&self) {
assert_eq!(self.status, reqwest::StatusCode::OK);
assert!(
self.content_type.starts_with("text/event-stream"),
"a streamed answer must carry the SSE content type, got {:?}",
self.content_type
);
}
}
/// The exact closed body of one delivered event. Nothing else is allowed to be carried.
fn expected_notification(level: &str, event: &str, outcome: &str) -> Value {
json!({
"jsonrpc": "2.0",
"method": "notifications/message",
"params": {
"level": level,
"logger": LOGGER_NAME,
"data": {"event": event, "outcome": outcome}
}
})
}
async fn logging_endpoint() -> LoggingEndpoint {
let registry = test_registry().await;
publish_agent_with_bindings(&registry, AGENT_SLUG, Vec::new()).await;
publish_agent_with_bindings(&registry, OTHER_AGENT_SLUG, Vec::new()).await;
let api_key = create_platform_api_key(
&registry,
AGENT_SLUG,
"mcp-logging",
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
)
.await;
let other_api_key = create_platform_api_key(
&registry,
OTHER_AGENT_SLUG,
"mcp-logging-other",
&[PlatformApiKeyScope::Read, PlatformApiKeyScope::Write],
)
.await;
let base_url = spawn_mcp_server(build_test_app(
registry.clone(),
Duration::from_millis(0),
Some("https://crank.example.com".to_owned()),
))
.await;
LoggingEndpoint {
client: reqwest::Client::new(),
base_url,
api_key,
other_api_key,
registry,
}
}
/// AT-3.18-01/03: the advertisement equals the implemented surface on both revisions.
#[tokio::test]
async fn advertisement_declares_the_logging_capability_on_both_revisions() {
let endpoint = logging_endpoint().await;
let discover = endpoint
.client
.post(endpoint.url(AGENT_SLUG))
.header(
reqwest::header::ACCEPT,
"application/json, text/event-stream",
)
.header(
reqwest::header::AUTHORIZATION,
format!("Bearer {}", endpoint.api_key),
)
.header("MCP-Protocol-Version", MODERN_REVISION)
.header("Mcp-Method", "server/discover")
.json(&json!({
"jsonrpc": "2.0",
"id": 1,
"method": "server/discover",
"params": {"_meta": {
META_PROTOCOL_VERSION: MODERN_REVISION,
META_CLIENT_CAPABILITIES: {},
META_CLIENT_INFO: {"name": "crank-logging-atdd", "version": "0.1.0"}
}}
}))
.send()
.await
.expect("the endpoint answers");
let discover: Value = discover.json().await.expect("a JSON body");
assert_eq!(
discover["result"]["capabilities"]["logging"],
json!({}),
"the modern advertisement must declare the implemented logging capability: {discover}"
);
let initialize = endpoint
.client
.post(endpoint.url(AGENT_SLUG))
.header(
reqwest::header::ACCEPT,
"application/json, text/event-stream",
)
.header(
reqwest::header::AUTHORIZATION,
format!("Bearer {}", endpoint.api_key),
)
.json(&json!({
"jsonrpc": "2.0",
"id": 2,
"method": "initialize",
"params": {"protocolVersion": LEGACY_REVISION, "capabilities": {}}
}))
.send()
.await
.expect("the endpoint answers");
let initialize: Value = initialize.json().await.expect("a JSON body");
assert_eq!(
initialize["result"]["capabilities"]["logging"],
json!({}),
"the legacy advertisement must declare the implemented logging capability: {initialize}"
);
// Control: a capability this story does not implement is still absent, so the assertion above is
// not a blanket "advertise everything" change.
assert!(
initialize["result"]["capabilities"]
.get("io.modelcontextprotocol/tasks")
.is_none(),
"an unimplemented extension must not appear: {initialize}"
);
endpoint.registry.ping().await.expect("the registry is up");
}
/// AT-3.18-01: setting a valid legacy level is acknowledged with one safe structured event.
#[tokio::test]
async fn legacy_set_level_acknowledges_with_a_closed_safe_event() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
let reply = endpoint.set_level(&session, json!("debug")).await;
reply.assert_stream();
assert_eq!(
reply.result(),
&json!({}),
"the pinned `logging/setLevel` result is empty: {}",
reply.response
);
assert_eq!(
reply.notifications,
vec![
expected_notification("notice", "mcp.logging.level_applied", "applied"),
expected_notification("info", "mcp.request.served", "ok"),
],
"the acknowledgment carries the applied level and the served outcome, nothing else"
);
assert!(
reply.raw.len() < 4_096,
"one notification is a few hundred bytes, never a payload echo"
);
}
/// AT-3.18-01: after the opt-in, a served request delivers its own safe event only.
#[tokio::test]
async fn legacy_served_request_delivers_only_the_closed_safe_event() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
endpoint.set_level(&session, json!("debug")).await;
let reply = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 61, "method": "tools/list", "params": {}}),
)
.await;
reply.assert_stream();
assert!(
reply.result().get("tools").is_some(),
"the business result is unchanged: {}",
reply.response
);
assert_eq!(
reply.notifications,
vec![expected_notification("info", "mcp.request.served", "ok")],
"a served request reports its outcome and nothing about the request"
);
}
/// AT-3.18-01 (redaction): a value the request carries can never reach a notification, while the
/// positive control proves the same search does find a reflected value elsewhere in the body.
#[tokio::test]
async fn a_request_value_can_never_reach_a_notification() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
endpoint.set_level(&session, json!("debug")).await;
let reply = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({
"jsonrpc": "2.0",
"id": 62,
"method": "tools/call",
"params": {
"name": CANARY,
"arguments": {"secret": CANARY},
"_meta": {"progressToken": CANARY}
}
}),
)
.await;
reply.assert_stream();
// Positive control: the existing product answer echoes the unknown tool name verbatim, so the
// canary is provably present in this very body — a "not found" search here would be meaningless.
let (code, message) = reply.error();
assert_eq!(code, -32602, "an unknown tool is a safe client error");
assert!(
message.contains(CANARY),
"the positive control must reflect the canary in the error message, got {message:?}"
);
// The delivered notification is exactly the closed safe body: no canary, no argument value.
for notification in &reply.notifications {
assert_eq!(
notification["params"]["data"]
.as_object()
.map(|data| {
let mut keys: Vec<&str> = data.keys().map(String::as_str).collect();
keys.sort_unstable();
keys
})
.unwrap_or_default(),
vec!["event", "outcome"],
"a notification data object carries exactly the two closed members: {notification}"
);
assert!(
!notification.to_string().contains(CANARY),
"a request value must never reach a notification: {notification}"
);
assert!(
notification["params"].get("id").is_none(),
"a notification is not a response: {notification}"
);
}
}
/// AT-3.18-02/03: the modern era opts in per request, and only from the pinned `_meta` key.
#[tokio::test]
async fn modern_level_is_per_request_and_requires_an_explicit_opt_in() {
let endpoint = logging_endpoint().await;
let opted_in = endpoint
.modern_stream_with_params(
"tools/list",
json!({"_meta": {
META_PROTOCOL_VERSION: MODERN_REVISION,
META_CLIENT_CAPABILITIES: {},
META_CLIENT_INFO: {"name": "crank-logging-atdd", "version": "0.1.0"},
META_LOG_LEVEL: "debug"
}}),
)
.await;
opted_in.assert_stream();
assert!(opted_in.result().get("tools").is_some());
assert_eq!(
opted_in.notifications,
vec![expected_notification("info", "mcp.request.served", "ok")],
"a request that opted in receives its safe event"
);
// The pinned modern schema: without the key the server MUST NOT send any notification.
let not_opted_in = endpoint.modern_stream("tools/list", json!({})).await;
assert_eq!(not_opted_in.status, reqwest::StatusCode::OK);
assert!(
not_opted_in.result().get("tools").is_some(),
"the business answer is unchanged without an opt-in: {}",
not_opted_in.response
);
assert!(
not_opted_in.notifications.is_empty(),
"no notification without an explicit opt-in, got {:?}",
not_opted_in.notifications
);
// An unknown level is treated as "not opted in" rather than as an error of the business request,
// and it never widens the accepted vocabulary.
let unknown = endpoint
.modern_stream_with_params(
"tools/list",
json!({"_meta": {
META_PROTOCOL_VERSION: MODERN_REVISION,
META_CLIENT_CAPABILITIES: {},
META_CLIENT_INFO: {"name": "crank-logging-atdd", "version": "0.1.0"},
META_LOG_LEVEL: "verbose"
}}),
)
.await;
assert!(unknown.result().get("tools").is_some());
assert!(
unknown.notifications.is_empty(),
"an unpinned level must not opt in, got {:?}",
unknown.notifications
);
}
/// AT-3.18-03: the delivered severities follow the ranged level of the legacy session.
#[tokio::test]
async fn legacy_severity_filter_is_honoured() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
// `error` is more severe than both a served request and a rejected one: neither is delivered.
endpoint.set_level(&session, json!("error")).await;
let served = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 71, "method": "tools/list", "params": {}}),
)
.await;
assert!(
served.notifications.is_empty(),
"a served event is below the `error` level, got {:?}",
served.notifications
);
let rejected = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 72, "method": "prompts/get", "params": {}}),
)
.await;
assert_eq!(
rejected.error().0,
-32602,
"a malformed request is a client error"
);
assert!(
rejected.notifications.is_empty(),
"a warning event is below the `error` level, got {:?}",
rejected.notifications
);
// `warning` admits the rejected event, and still not the served one.
endpoint.set_level(&session, json!("warning")).await;
let rejected = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 73, "method": "prompts/get", "params": {}}),
)
.await;
assert_eq!(
rejected.notifications,
vec![expected_notification(
"warning",
"mcp.request.rejected",
"invalid_params"
)],
"the rejection is delivered at the `warning` level"
);
let served = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 74, "method": "tools/list", "params": {}}),
)
.await;
assert!(
served.notifications.is_empty(),
"an info event is still below the `warning` level, got {:?}",
served.notifications
);
}
/// AT-3.18-02: a malformed level is a revision-correct safe error with bounded work, and it never
/// changes the level of the client or of anybody else.
#[tokio::test]
async fn a_malformed_level_is_a_safe_error_without_state_change() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
endpoint.set_level(&session, json!("error")).await;
// A value outside the pinned union, a non-string shape, a missing member and an oversized value
// all share one safe detail: the client cannot tell them apart and nothing is echoed back.
for level in [
json!("verbose"),
json!("INFO"),
json!(7),
json!(null),
json!({}),
json!("i".repeat(64)),
] {
let reply = endpoint.set_level(&session, level.clone()).await;
assert_eq!(
reply.error(),
(-32602, INVALID_LEVEL.to_owned()),
"a malformed level is one safe invalid-params detail for {level}"
);
if let Some(text) = level.as_str() {
assert!(
!reply.raw.contains(text),
"the offending value must never be echoed back"
);
}
assert!(
reply.notifications.is_empty(),
"a rejected level is not an opt-in, got {:?}",
reply.notifications
);
}
// An oversized value is refused by the fixed bound: the answer stays a short safe detail and the
// value is not reflected, which is the observable half of "bounded work".
let oversized = "i".repeat(65_536);
let reply = endpoint.set_level(&session, json!(oversized)).await;
assert_eq!(reply.error(), (-32602, INVALID_LEVEL.to_owned()));
assert!(
!reply.raw.contains(&oversized),
"an oversized level must not be reflected"
);
assert!(
reply.raw.len() < 4_096,
"the answer to an oversized level is bounded, got {} bytes",
reply.raw.len()
);
let missing = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 81, "method": "logging/setLevel", "params": {}}),
)
.await;
assert_eq!(missing.error(), (-32602, INVALID_LEVEL.to_owned()));
// The level of the session is unchanged (`error` was set before the malformed attempts), so a
// served request still delivers nothing...
let served = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 82, "method": "tools/list", "params": {}}),
)
.await;
assert!(
served.notifications.is_empty(),
"a malformed level must not change the active level, got {:?}",
served.notifications
);
// ...and a valid level still works, which proves the assertions above are not vacuous.
endpoint.set_level(&session, json!("debug")).await;
let served = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 83, "method": "tools/list", "params": {}}),
)
.await;
assert_eq!(served.notifications.len(), 1);
}
/// AT-3.18-02 (era matrix): the modern schema declares no `logging/setLevel`, so the same wire name
/// is a method-not-found there and never reaches the legacy service.
#[tokio::test]
async fn the_modern_era_has_no_set_level_method() {
let endpoint = logging_endpoint().await;
let reply = endpoint
.modern_stream("logging/setLevel", json!({"level": "debug"}))
.await;
let (code, message) = reply.error();
assert_eq!(
code, -32601,
"the modern revision has no logging/setLevel: {}",
reply.response
);
assert!(
!message.contains("debug"),
"the rejection must not echo the level: {message:?}"
);
// And the level was not applied through a wrong-era route: a modern request stays silent.
let after = endpoint.modern_stream("tools/list", json!({})).await;
assert!(after.notifications.is_empty());
}
/// AT-3.18-01/03 (independence): a level belongs to one client context, so a second session and a
/// second Agent keep their own (or no) level.
#[tokio::test]
async fn a_level_never_leaks_to_another_client() {
let endpoint = logging_endpoint().await;
let session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
endpoint.set_level(&session, json!("debug")).await;
// Another initialized session of the same Agent never opted in.
let other_session = endpoint.legacy_session(AGENT_SLUG, &endpoint.api_key).await;
assert_ne!(
session, other_session,
"each initialize mints its own session"
);
let other = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&other_session,
json!({"jsonrpc": "2.0", "id": 91, "method": "tools/list", "params": {}}),
)
.await;
assert!(
other.notifications.is_empty(),
"a session that never opted in must stay silent, got {:?}",
other.notifications
);
assert!(other.result().get("tools").is_some());
// The opted-in session still receives its own events...
let opted_in = endpoint
.legacy_post(
AGENT_SLUG,
&endpoint.api_key,
&session,
json!({"jsonrpc": "2.0", "id": 92, "method": "tools/list", "params": {}}),
)
.await;
assert_eq!(opted_in.notifications.len(), 1);
// ...and another Agent's session is unaffected by this Agent's level, both before and after it
// sets its own.
let other_agent_session = endpoint
.legacy_session(OTHER_AGENT_SLUG, &endpoint.other_api_key)
.await;
let other_agent = endpoint
.legacy_post(
OTHER_AGENT_SLUG,
&endpoint.other_api_key,
&other_agent_session,
json!({"jsonrpc": "2.0", "id": 93, "method": "tools/list", "params": {}}),
)
.await;
assert!(
other_agent.notifications.is_empty(),
"another Agent must not inherit a level, got {:?}",
other_agent.notifications
);
endpoint
.legacy_post(
OTHER_AGENT_SLUG,
&endpoint.other_api_key,
&other_agent_session,
json!({"jsonrpc": "2.0", "id": 94, "method": "logging/setLevel", "params": {"level": "error"}}),
)
.await;
let other_agent_error = endpoint
.legacy_post(
OTHER_AGENT_SLUG,
&endpoint.other_api_key,
&other_agent_session,
json!({"jsonrpc": "2.0", "id": 95, "method": "tools/list", "params": {}}),
)
.await;
assert!(
other_agent_error.notifications.is_empty(),
"the other Agent's own `error` level admits no served event"
);
}
@@ -114,8 +114,8 @@ fn now_rfc3339() -> String {
.unwrap_or_else(|error| format!("unformatted-utc ({error})"))
}
/// A single timed `resources/list`, built directly on `reqwest` so transport/timeout/HTTP failures are
/// recorded as outcomes instead of aborting the run.
/// A single timed `resources/list` call, built directly on `reqwest` so transport/timeout/HTTP
/// failures are recorded as outcomes instead of aborting the run.
async fn timed_list(
endpoint: &ResourceEndpoint,
revision: &'static str,
-4
View File
@@ -82,9 +82,6 @@ pub(super) struct AppState {
session_slots: Arc<Semaphore>,
pub(super) credential_verifier: SharedMachineCredentialVerifier,
allowed_origins: AllowedOrigins,
/// Story 3.18: the bounded in-memory `logging/setLevel` opt-in of the legacy sessions. It is a
/// client-scoped level, never a process-global one, and it needs no schema migration.
pub(super) logging_levels: Arc<crate::protocol::LogLevelStore>,
}
#[derive(Clone)]
@@ -251,7 +248,6 @@ fn build_app_inner(
session_slots: Arc::new(Semaphore::new(max_concurrent_sessions)),
credential_verifier,
allowed_origins: AllowedOrigins::new(public_base_url),
logging_levels: Arc::new(crate::protocol::LogLevelStore::new()),
});
if start_background_workers {
spawn_approval_recovery(Arc::clone(&state));
@@ -67,12 +67,6 @@ pub(super) async fn handle_modern_request(
.as_deref()
.unwrap_or(crate::jsonrpc::MODERN_PROTOCOL_VERSION);
// Story 3.18: the modern revision carries the log level of this request in
// `_meta["io.modelcontextprotocol/logLevel"]` (SEP-2577); the former `logging/setLevel` request
// does not exist here. Absent, non-string or unknown values mean "not opted in", so no
// `notifications/message` is emitted for this request.
crate::protocol::set_active_level(crate::protocol::modern_request_level(message));
// A notification carries no `id`. It is acknowledged before the request-only header rules: the
// mandatory `Mcp-Method`/`Mcp-Name` pair applies to requests, not to notifications (protocol era
// matrix row 18). The envelope, identity and mixed-carrier checks — and authentication — have
+11 -87
View File
@@ -14,22 +14,20 @@ use crate::{
method_name, params, request_id,
},
protocol::{
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision,
EVENT_LEVEL_APPLIED, EnvelopeKind, INVALID_LEVEL, Kind, LoggingOutcome, MethodHandler,
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, RequestEra,
ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
ServiceContext, SetLevelCommand, ToolCallCommand, ToolsCommand, ToolsListCommand,
ToolsOutcome, ambiguous_session_carrier_response, handle_completion_command,
handle_logging_command, handle_prompts_command, handle_resources_command,
handle_tools_command, resolve_request_identity,
CompletionCommand, CompletionOutcome, ContinuationSupport, DispatchDecision, EnvelopeKind,
Kind, MethodHandler, PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome,
RequestEra, ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome,
ambiguous_session_carrier_response, handle_completion_command, handle_prompts_command,
handle_resources_command, handle_tools_command, resolve_request_identity,
},
rate_limit::{rate_limited_jsonrpc_response, rate_limited_status_response},
request_context::RequestContext,
tool_error::execution_locale,
transport::{
accepts_event_stream, negotiate_post_response_mode, session_id_from_headers, sse_response,
transport_response, validate_get_accept_header, validate_origin,
validate_session_protocol_version, with_request_id_header,
negotiate_post_response_mode, session_id_from_headers, sse_response, transport_response,
validate_get_accept_header, validate_origin, validate_session_protocol_version,
with_request_id_header,
},
};
use axum::{
@@ -226,14 +224,8 @@ pub(super) async fn mcp_post(
"mcp request received"
);
let response = crate::protocol::logging_scope(mcp_post_response(
&path,
state,
&headers,
&message,
&transport_correlation,
))
.await;
let response =
mcp_post_response(&path, state, &headers, &message, &transport_correlation).await;
request_metrics.complete(&response);
with_request_id_header(response, &transport_request_id)
}
@@ -258,13 +250,6 @@ async fn mcp_post_response(
Ok(mode) => mode,
Err(status) => return status.into_response(),
};
// Story 3.18: a server notification is delivered only on the SSE stream, so the logging
// projection records whether this request offered it. This is an admission fact of the same
// `Accept` header the mode above was negotiated from.
if accepts_event_stream(headers) {
crate::protocol::set_sse_acceptable();
}
// A conflicting duplicate session carrier is an ambiguous identity: it must not be resolved to
// one of its values. The carrier itself cannot tell which era the request belongs to, so the
// diagnostic is read from the non-ambiguous part of the request (matrix row 17) — a consumer of
@@ -342,17 +327,6 @@ async fn mcp_post_response(
}
}
// Story 3.18: the legacy logging opt-in belongs to this session, so it is read before dispatch.
// A session that never sent `logging/setLevel` has no level, which is what the pinned schema
// describes as "not opted in" (no notification is delivered).
if matches!(identity.era, RequestEra::Legacy) {
crate::protocol::set_active_level(
request_session_id
.as_deref()
.and_then(|session_id| state.logging_levels.get(session_id)),
);
}
let required_scope = match method_name(message) {
Some("tools/call") => PlatformApiKeyScope::Write,
_ => PlatformApiKeyScope::Read,
@@ -979,56 +953,6 @@ async fn mcp_post_response(
}
}
}
// Story 3.18: the pinned legacy `logging/setLevel`. The level belongs to the initialized
// session of this request, so setting it can never change another client's level. The request
// answers an empty result; the acknowledgment event is filtered by the level it just set.
DispatchDecision::Allowed {
handler: MethodHandler::LoggingSetLevel,
..
} if is_request(message) => {
let session = match require_initialized_session(&state, path, headers, message).await {
Ok(session) => session,
Err(response) => return response,
};
let command: SetLevelCommand = match serde_json::from_value(params(message)) {
Ok(command) => command,
// A non-string, missing or otherwise unparsable level shares the one safe detail of a
// value outside the pinned union: nothing the client sent is echoed back.
Err(_) => {
return transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, INVALID_LEVEL),
response_mode,
None,
Some(&session.protocol_version),
);
}
};
match handle_logging_command(&state.logging_levels, &session.id, command) {
LoggingOutcome::Applied(level) => {
crate::protocol::set_active_level(Some(level));
crate::protocol::note(
crate::protocol::LogLevel::Notice,
EVENT_LEVEL_APPLIED,
"applied",
);
transport_response(
StatusCode::OK,
jsonrpc_result(request_id(message), json!({})),
response_mode,
None,
Some(&session.protocol_version),
)
}
LoggingOutcome::InvalidParams(detail) => transport_response(
StatusCode::OK,
jsonrpc_error(request_id(message), -32602, detail),
response_mode,
None,
Some(&session.protocol_version),
),
}
}
// A notification whose method the registration does not map to this adapter's handlers is
// acknowledged without being dispatched, exactly as before.
_ if is_notification(message) => StatusCode::ACCEPTED.into_response(),
@@ -121,53 +121,3 @@ impl ActiveStreamGuard {
})
}
}
#[cfg(test)]
mod tests {
use crank_metrics::McpMethod;
use serde_json::json;
use super::normalized_mcp_method;
/// AT-3.18-02: the metric label of the logging request is a member of the closed label enum, so
/// neither the level nor any other client-supplied identifier can reach the label space. There is
/// no mapping from a request value to a label anywhere in this file.
#[test]
fn a_logging_request_can_only_produce_a_fixed_metric_label() {
for level in [
json!("debug"),
json!("verbose"),
json!("crank-canary-9f7620e5-aa41-4b0d"),
json!(7),
json!(null),
] {
let message = json!({
"jsonrpc": "2.0",
"id": 1,
"method": "logging/setLevel",
"params": {"level": level}
});
assert_eq!(
normalized_mcp_method(&message),
McpMethod::Unsupported,
"the method label is a fixed enum member, never the request value"
);
}
assert_eq!(McpMethod::Unsupported.as_str(), "unsupported");
// Every label value of the enum is a pinned literal, so the label domain cannot be widened by
// a request at all.
assert!(
McpMethod::VALUES.iter().all(|value| value
.chars()
.all(|character| character.is_ascii_lowercase() || character == '_')),
"every method label is a fixed lowercase literal: {:?}",
McpMethod::VALUES
);
// A malformed envelope has its own fixed label as well.
assert_eq!(
normalized_mcp_method(&json!({"level": "debug"})),
McpMethod::Invalid
);
}
}
@@ -18,9 +18,6 @@ pub const CURRENT_PROTOCOL_VERSION: &str = LEGACY_PROTOCOL_VERSION;
pub const META_PROTOCOL_VERSION_KEY: &str = "io.modelcontextprotocol/protocolVersion";
pub const META_CLIENT_CAPABILITIES_KEY: &str = "io.modelcontextprotocol/clientCapabilities";
pub const META_CLIENT_INFO_KEY: &str = "io.modelcontextprotocol/clientInfo";
/// `_meta` key of the per-request log level (Story 3.18). SEP-2577 replaces the former
/// `logging/setLevel` request of the legacy era with this per-request opt-in.
pub const META_LOG_LEVEL_KEY: &str = "io.modelcontextprotocol/logLevel";
/// Result `_meta` key carrying the self-reported server identity (pinned `DiscoverResult`).
pub const META_SERVER_INFO_KEY: &str = "io.modelcontextprotocol/serverInfo";
@@ -1,338 +0,0 @@
//! Story 3.18: safe MCP server logging (FR-19).
//!
//! Scope of this module is the server side of the pinned `logging` capability of the two approved
//! revisions, and nothing else:
//!
//! * `2025-11-25` (legacy session era) declares `logging/setLevel` as a client request with one
//! `level` of the pinned `LoggingLevel` union, and `logging?: object` in `ServerCapabilities`.
//! The request sets the severity a client wants to receive for its own session.
//! * `2026-07-28` (modern stateless era) has no `logging/setLevel` method at all: SEP-2577 replaces
//! it with the per-request `_meta["io.modelcontextprotocol/logLevel"]`, and the schema says that
//! when that key is absent "the server MUST NOT send any notifications/message notifications for
//! this request". The `logging` capability and `notifications/message` themselves stay in the
//! pinned schema as deprecated for at least twelve months.
//!
//! The answer of this story is therefore the narrow one the contract offers: an opt-in level that
//! belongs to the current negotiated client context (one legacy session, or one modern request —
//! never a process-global level shared by every agent), and `notifications/message` events that are
//! built **only** from the closed safe vocabulary below.
//!
//! Redaction is structural, not a filter: no request payload, credential, internal error cause,
//! Prompt/Resource/Tool name, URI, argument value or any other user-supplied value is ever accepted
//! by this module, so none of them can reach the wire. A `notifications/message` body is exactly
//! `{"level": <severity of the event>, "logger": "crank-mcp-server", "data": {"event": <closed name>,
//! "outcome": <closed label>}}` — every member of it is a `&'static str` from this file.
//!
//! Bounds (issue requirement: bounded frequency/queues/bytes, logging never blocks execution and
//! never replaces the audit trail):
//! * at most one event per response is recorded, and at most [`MAX_PENDING_NOTIFICATIONS`] are
//! drained into one response — a fixed, per-response frequency bound;
//! * every event has a fixed size and no variable input, so the byte bound follows from the count
//! bound without a separate accounting path;
//! * recording is a bounded in-memory push that drops the event when the buffer is full, the active
//! level is unset, or the task has no request scope. No I/O, no lock acquisition that can wait, and
//! no error path: logging can never fail or slow down the request it describes.
//! * the legacy opt-in table is a bounded in-memory map read/written with `try_lock` only.
use std::{
cell::RefCell,
collections::HashMap,
future::Future,
sync::{Mutex, MutexGuard},
};
use serde::Deserialize;
use serde_json::{Value, json};
use tokio::task_local;
/// The pinned `LoggingLevel` union: RFC 5424 severities, ordered from the most verbose to the most
/// severe. The ordering is the filtering contract — a client is sent the events at or above its
/// level.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum LogLevel {
Debug,
Info,
Notice,
Warning,
Error,
Critical,
Alert,
Emergency,
}
impl LogLevel {
/// The exact wire literal of this level.
pub(crate) const fn as_str(self) -> &'static str {
match self {
Self::Debug => "debug",
Self::Info => "info",
Self::Notice => "notice",
Self::Warning => "warning",
Self::Error => "error",
Self::Critical => "critical",
Self::Alert => "alert",
Self::Emergency => "emergency",
}
}
/// Exact parse of the eight pinned literals.
///
/// Nothing is coerced: no case folding, no aliases (`warn`), no numeric severities. A value that
/// is not one of the pinned strings is malformed, which is what the pinned `LoggingLevel` type
/// says and what `InvalidParamsError` is for.
pub(crate) fn parse(value: &str) -> Option<Self> {
match value {
"debug" => Some(Self::Debug),
"info" => Some(Self::Info),
"notice" => Some(Self::Notice),
"warning" => Some(Self::Warning),
"error" => Some(Self::Error),
"critical" => Some(Self::Critical),
"alert" => Some(Self::Alert),
"emergency" => Some(Self::Emergency),
_ => None,
}
}
}
/// Bound of `params.level` before it is compared: the longest pinned literal is nine bytes, so a
/// value beyond this cannot be a level and must not be scanned further.
pub(crate) const MAX_LEVEL_BYTES: usize = 16;
/// The one safe detail of a malformed `logging/setLevel`: it never echoes the offending value, so an
/// oversized or hostile value cannot be reflected back or widened into an error payload.
pub(crate) const INVALID_LEVEL: &str = "invalid logging level";
/// Notifications drained into one response (frequency bound).
pub(crate) const MAX_PENDING_NOTIFICATIONS: usize = 4;
/// Bound of the in-memory legacy opt-in table (memory bound; see [`LogLevelStore`]).
pub(crate) const MAX_TRACKED_SESSIONS: usize = 1_024;
/// The fixed logger name carried by every notification. It is a server constant, never a
/// client-supplied or catalog-supplied value.
const LOGGER_NAME: &str = "crank-mcp-server";
/// Closed safe vocabulary: the server served the request.
pub(crate) const EVENT_SERVED: &str = "mcp.request.served";
/// Closed safe vocabulary: the request was rejected as invalid before any service work.
pub(crate) const EVENT_REJECTED: &str = "mcp.request.rejected";
/// Closed safe vocabulary: the request failed on the server side.
pub(crate) const EVENT_FAILED: &str = "mcp.request.failed";
/// Closed safe vocabulary: this client set its logging level.
pub(crate) const EVENT_LEVEL_APPLIED: &str = "mcp.logging.level_applied";
/// The `params` of one `logging/setLevel` request as the legacy adapter parses it from the wire form.
///
/// Only the single pinned member exists here: an unknown member is ignored by serde, and a `level`
/// that is not a string is a deserialization error, which the adapter answers with the same safe
/// [`INVALID_LEVEL`] detail instead of a serde diagnostic.
#[derive(Debug, Deserialize)]
pub(crate) struct SetLevelCommand {
pub(crate) level: String,
}
impl SetLevelCommand {
/// The bounded input contract of AC2: the level is length-bounded and compared exactly, so a
/// malformed or oversized value is refused with bounded work and one safe detail.
pub(crate) fn validate(&self) -> Result<LogLevel, &'static str> {
if self.level.is_empty() || self.level.len() > MAX_LEVEL_BYTES {
return Err(INVALID_LEVEL);
}
LogLevel::parse(&self.level).ok_or(INVALID_LEVEL)
}
}
/// A neutral outcome of the shared `logging/setLevel` service.
pub(crate) enum LoggingOutcome {
/// The level of this client context was accepted.
Applied(LogLevel),
/// Malformed or oversized level: one safe detail, no echoed input.
InvalidParams(&'static str),
}
/// One recorded event of the closed vocabulary.
#[derive(Debug, Clone, Copy)]
struct SafeEvent {
level: LogLevel,
event: &'static str,
outcome: &'static str,
}
/// The request-scoped logging state: the level this client opted in to, whether the client offered
/// the SSE response mode that is the only carrier of a server notification, and the bounded events
/// this response will carry.
#[derive(Default)]
struct RequestLog {
active: Option<LogLevel>,
sse_acceptable: bool,
pending: Vec<SafeEvent>,
}
task_local! {
/// Per-request logging scope. Installed by the HTTP entry point of the MCP endpoint, so two
/// concurrently served requests never share a level or a buffer. Code outside such a scope
/// (unit tests, background workers) sees a no-op.
static REQUEST_LOG: RefCell<RequestLog>;
}
/// Run one request inside its own logging scope.
pub(crate) async fn scoped<F: Future>(future: F) -> F::Output {
REQUEST_LOG
.scope(RefCell::new(RequestLog::default()), future)
.await
}
/// Activate (or clear) the level of the current client context. Outside a scope this is a no-op.
pub(crate) fn set_active_level(level: Option<LogLevel>) {
let _ = REQUEST_LOG.try_with(|log| {
if let Ok(mut log) = log.try_borrow_mut() {
log.active = level;
}
});
}
/// Remember that this request offered `text/event-stream`, the only carrier of a notification.
pub(crate) fn set_sse_acceptable() {
let _ = REQUEST_LOG.try_with(|log| {
if let Ok(mut log) = log.try_borrow_mut() {
log.sse_acceptable = true;
}
});
}
/// Record one event of the closed vocabulary for the level this client opted in to.
///
/// Everything below the active level, every event without an active level (the client did not opt
/// in), and every event beyond the fixed buffer bound is dropped silently: the caller never branches
/// on logging.
pub(crate) fn note(level: LogLevel, event: &'static str, outcome: &'static str) {
let _ = REQUEST_LOG.try_with(|log| {
let Ok(mut log) = log.try_borrow_mut() else {
return;
};
let Some(active) = log.active else {
return;
};
if level < active || log.pending.len() >= MAX_PENDING_NOTIFICATIONS {
return;
}
log.pending.push(SafeEvent {
level,
event,
outcome,
});
});
}
/// The pending events as wire `notifications/message` bodies, and whether this request can carry
/// them at all. Draining is the last step of the response projection, so a notification can never be
/// delivered twice or survive into another request.
pub(crate) fn take_notifications() -> Vec<Value> {
REQUEST_LOG
.try_with(|log| {
let Ok(mut log) = log.try_borrow_mut() else {
return Vec::new();
};
if !log.sse_acceptable {
// A JSON body has no place for a server notification: the event is not delivered
// instead of being smuggled into the result object.
log.pending.clear();
return Vec::new();
}
std::mem::take(&mut log.pending)
.into_iter()
.map(|event| {
json!({
"jsonrpc": "2.0",
"method": "notifications/message",
"params": {
"level": event.level.as_str(),
"logger": LOGGER_NAME,
"data": {
"event": event.event,
"outcome": event.outcome,
}
}
})
})
.collect()
})
.unwrap_or_default()
}
/// The per-session opt-in of the legacy era.
///
/// The login belongs to the session the client negotiated, so a level set by one agent's client can
/// never apply to another. It is deliberately **in-memory only**: persisting it would need a schema
/// migration of the transport session store, and the deprecated capability does not justify that.
///
/// shortcut: the table is per process — a level set on one replica is not seen by another replica
/// serving the same session, and a restart clears it; upgrade to the session store if a durable or
/// cross-replica level is ever required.
#[derive(Default)]
pub(crate) struct LogLevelStore {
levels: Mutex<HashMap<String, LogLevel>>,
}
impl LogLevelStore {
pub(crate) fn new() -> Self {
Self::default()
}
/// Store the level of one session. Never waits and never fails: on lock contention the update is
/// skipped rather than blocking the request.
pub(crate) fn set(&self, session_id: &str, level: LogLevel) {
let Some(mut levels) = self.lock() else {
return;
};
if levels.len() >= MAX_TRACKED_SESSIONS && !levels.contains_key(session_id) {
// Bounded table: the oldest opt-ins are dropped instead of growing without a limit. A
// dropped client simply stops receiving notifications until it sets its level again.
levels.clear();
}
levels.insert(session_id.to_owned(), level);
}
/// The level of one session, if this process still remembers it.
pub(crate) fn get(&self, session_id: &str) -> Option<LogLevel> {
self.lock()?.get(session_id).copied()
}
fn lock(&self) -> Option<MutexGuard<'_, HashMap<String, LogLevel>>> {
self.levels.try_lock().ok()
}
}
/// Serve one `logging/setLevel` request of the legacy era (AC1/AC2).
///
/// The command has already been parsed from the wire form, so this function only validates and
/// records; it never reads the registry, the catalog or any stored value.
pub(crate) fn handle_logging_command(
store: &LogLevelStore,
session_id: &str,
command: SetLevelCommand,
) -> LoggingOutcome {
match command.validate() {
Ok(level) => {
store.set(session_id, level);
LoggingOutcome::Applied(level)
}
Err(detail) => LoggingOutcome::InvalidParams(detail),
}
}
/// The level a modern request asked for in `_meta`.
///
/// The pinned schema says the server must not send `notifications/message` for a request that does
/// not carry the key, so an absent, non-string or unknown value is simply "not opted in": it is not
/// an error of the business request and never widens the accepted vocabulary.
pub(crate) fn modern_request_level(message: &Value) -> Option<LogLevel> {
let meta = crate::jsonrpc::params(message).get("_meta")?.clone();
let value = meta.get(crate::jsonrpc::META_LOG_LEVEL_KEY)?.as_str()?;
LogLevel::parse(value)
}
#[cfg(test)]
#[path = "logging_tests.rs"]
mod tests;
@@ -1,316 +0,0 @@
//! Unit contract of Story 3.18: the pinned level vocabulary, the bounded input contract of
//! `logging/setLevel`, the request-scoped bounded event buffer and the closed safe notification
//! shape.
use serde_json::json;
use super::*;
/// Parse one `logging/setLevel` params object and validate its level, or `None` when the shape itself
/// is malformed (which the adapter answers with the same safe detail).
fn validate(level: &str) -> Option<Result<LogLevel, &'static str>> {
let command: SetLevelCommand = serde_json::from_value(json!({ "level": level })).ok()?;
Some(command.validate())
}
#[test]
fn every_pinned_level_is_accepted_exactly_once_and_in_severity_order() {
// The pinned `LoggingLevel` union of both revisions, most verbose first.
let pinned = [
("debug", LogLevel::Debug),
("info", LogLevel::Info),
("notice", LogLevel::Notice),
("warning", LogLevel::Warning),
("error", LogLevel::Error),
("critical", LogLevel::Critical),
("alert", LogLevel::Alert),
("emergency", LogLevel::Emergency),
];
for (index, (literal, expected)) in pinned.iter().enumerate() {
assert_eq!(
LogLevel::parse(literal),
Some(*expected),
"{literal} is a pinned level"
);
assert_eq!(
expected.as_str(),
*literal,
"the wire literal of a level is exactly the pinned string"
);
assert_eq!(
*expected as usize, index,
"the severity ordering of {literal} must follow the RFC 5424 order"
);
assert_eq!(
validate(literal),
Some(Ok(*expected)),
"{literal} must be accepted through the wire shape too"
);
}
assert!(
pinned.windows(2).all(|pair| pair[0].1 < pair[1].1),
"severity must be strictly increasing so the filter is `event >= level`"
);
}
#[test]
fn nothing_outside_the_pinned_union_is_a_level() {
for value in [
"",
"warn",
"WARN",
"Info",
"information",
" debug",
"debug ",
"0",
"7",
"emergency!",
"debug\u{0}",
"информация",
] {
assert_eq!(
LogLevel::parse(value),
None,
"{value:?} is not one of the pinned literals and must never be coerced into one"
);
assert_eq!(
validate(value),
Some(Err(INVALID_LEVEL)),
"a value outside the union is a bounded invalid-params detail, got {value:?}"
);
}
}
#[test]
fn malformed_level_shapes_share_one_safe_detail() {
// A `level` the schema types as a string, sent as something else: a deserialization error that the
// adapter answers with the same safe detail. It never echoes what the client sent.
for value in [json!(7), json!(1.5), json!(0)] {
assert!(
serde_json::from_value::<SetLevelCommand>(json!({ "level": value })).is_err(),
"a numeric level is not a pinned LoggingLevel"
);
}
for value in [json!(null), json!({}), json!(["info"]), json!(true)] {
assert!(
serde_json::from_value::<SetLevelCommand>(json!({ "level": value })).is_err(),
"a non-string level is not a pinned LoggingLevel"
);
}
assert!(
serde_json::from_value::<SetLevelCommand>(json!({})).is_err(),
"the pinned request requires `level`"
);
// Control: the same safe detail is what an unknown string produces, so both malformed shapes are
// indistinguishable on the wire and neither discloses what was sent.
assert_eq!(validate("verbose"), Some(Err(INVALID_LEVEL)));
assert!(
INVALID_LEVEL.len() < 64,
"the detail stays a fixed short text"
);
}
#[test]
fn an_oversized_level_is_refused_before_any_comparison() {
let oversized = "i".repeat(MAX_LEVEL_BYTES + 1);
assert_eq!(validate(&oversized), Some(Err(INVALID_LEVEL)));
// Positive control: the bound is not so tight that a pinned literal is refused.
assert_eq!(validate("emergency"), Some(Ok(LogLevel::Emergency)));
}
#[test]
fn the_session_opt_in_is_per_session_and_bounded() {
let store = LogLevelStore::new();
store.set("session-a", LogLevel::Error);
store.set("session-b", LogLevel::Debug);
assert_eq!(store.get("session-a"), Some(LogLevel::Error));
assert_eq!(store.get("session-b"), Some(LogLevel::Debug));
assert_eq!(
store.get("session-c"),
None,
"a session that never opted in must not inherit another session's level"
);
// The table stays bounded: filling it past the cap drops the previous opt-ins instead of growing.
for index in 0..MAX_TRACKED_SESSIONS {
store.set(&format!("filler-{index}"), LogLevel::Info);
}
store.set("session-after-cap", LogLevel::Alert);
assert_eq!(store.get("session-after-cap"), Some(LogLevel::Alert));
}
#[tokio::test]
async fn an_event_is_delivered_only_at_or_above_the_opted_in_level() {
// One closed-vocabulary event per severity, recorded inside a request scope that offered SSE.
for (active, expected) in [
(LogLevel::Debug, 4usize),
(LogLevel::Info, 4),
(LogLevel::Notice, 3),
(LogLevel::Warning, 2),
(LogLevel::Error, 1),
(LogLevel::Critical, 0),
(LogLevel::Alert, 0),
(LogLevel::Emergency, 0),
] {
let delivered = scoped(async move {
set_active_level(Some(active));
set_sse_acceptable();
note(LogLevel::Info, EVENT_SERVED, "ok");
note(LogLevel::Notice, EVENT_LEVEL_APPLIED, "applied");
note(LogLevel::Warning, EVENT_REJECTED, "invalid_params");
note(LogLevel::Error, EVENT_FAILED, "internal");
take_notifications()
})
.await;
assert_eq!(
delivered.len(),
expected,
"level {} must deliver exactly the events at or above it",
active.as_str()
);
}
}
#[tokio::test]
async fn without_an_opt_in_nothing_is_even_recorded() {
// Outside a scope (no request, e.g. a background worker): a no-op.
note(LogLevel::Info, EVENT_SERVED, "ok");
assert!(take_notifications().is_empty());
// Inside a scope without an opted-in level.
let no_level = scoped(async {
set_sse_acceptable();
note(LogLevel::Error, EVENT_FAILED, "internal");
take_notifications()
})
.await;
assert!(
no_level.is_empty(),
"the pinned modern schema forbids notifications for a client that did not opt in"
);
}
#[tokio::test]
async fn a_level_is_present_but_the_client_offered_no_stream() {
let delivered = scoped(async {
set_active_level(Some(LogLevel::Debug));
note(LogLevel::Error, EVENT_FAILED, "internal");
take_notifications()
})
.await;
assert!(
delivered.is_empty(),
"a JSON body has no carrier for notifications/message; the event is dropped, not smuggled in"
);
}
#[tokio::test]
async fn the_buffer_is_bounded_and_drains_once() {
let (first, second) = scoped(async {
set_active_level(Some(LogLevel::Debug));
set_sse_acceptable();
for _ in 0..(MAX_PENDING_NOTIFICATIONS * 4) {
note(LogLevel::Info, EVENT_SERVED, "ok");
}
let first = take_notifications();
let second = take_notifications();
(first, second)
})
.await;
assert_eq!(
first.len(),
MAX_PENDING_NOTIFICATIONS,
"the per-response frequency bound"
);
assert!(
second.is_empty(),
"a delivered event must not survive into a later response"
);
}
#[tokio::test]
async fn the_notification_body_is_exactly_the_closed_safe_shape() {
let delivered = scoped(async {
set_active_level(Some(LogLevel::Debug));
set_sse_acceptable();
note(LogLevel::Warning, EVENT_REJECTED, "invalid_params");
take_notifications()
})
.await;
assert_eq!(
delivered,
vec![json!({
"jsonrpc": "2.0",
"method": "notifications/message",
"params": {
"level": "warning",
"logger": "crank-mcp-server",
"data": {"event": "mcp.request.rejected", "outcome": "invalid_params"}
}
})],
"`params` carries only the severity, the fixed logger name and the closed data object"
);
// A notification has no `id`, so it can never be mistaken for a response.
assert!(delivered[0].get("id").is_none());
}
#[test]
fn the_modern_level_is_read_from_the_pinned_meta_key_only() {
let modern = |meta: Value| json!({"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {"_meta": meta}});
assert_eq!(
modern_request_level(&modern(
json!({ "io.modelcontextprotocol/logLevel": "error" })
)),
Some(LogLevel::Error)
);
// Not opted in: an absent key, a non-string value and an unknown literal are all "no level".
assert_eq!(modern_request_level(&modern(json!({}))), None);
assert_eq!(
modern_request_level(&modern(json!({ "io.modelcontextprotocol/logLevel": 7 }))),
None
);
assert_eq!(
modern_request_level(&modern(
json!({ "io.modelcontextprotocol/logLevel": "verbose" })
)),
None
);
// A level under another key is not the pinned carrier.
assert_eq!(
modern_request_level(&modern(json!({ "logLevel": "error" }))),
None
);
assert_eq!(
modern_request_level(&json!({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})),
None
);
}
#[test]
fn the_command_records_the_level_of_its_own_session_only() {
let store = LogLevelStore::new();
store.set("other-session", LogLevel::Debug);
let command: SetLevelCommand =
serde_json::from_value(json!({ "level": "critical" })).expect("a pinned level parses");
let outcome = handle_logging_command(&store, "this-session", command);
assert!(matches!(
outcome,
LoggingOutcome::Applied(LogLevel::Critical)
));
assert_eq!(store.get("this-session"), Some(LogLevel::Critical));
assert_eq!(
store.get("other-session"),
Some(LogLevel::Debug),
"setting one session's level must never change another client's level"
);
// A malformed level changes nothing.
let malformed: SetLevelCommand =
serde_json::from_value(json!({ "level": "verbose" })).expect("the shape parses");
assert!(matches!(
handle_logging_command(&store, "this-session", malformed),
LoggingOutcome::InvalidParams(INVALID_LEVEL)
));
assert_eq!(store.get("this-session"), Some(LogLevel::Critical));
}
@@ -26,7 +26,6 @@ use crate::transport::{json_response, protocol_version_from_headers, singleton_h
mod command;
mod completion;
mod logging;
mod prompts;
mod registry;
mod resources;
@@ -36,11 +35,6 @@ pub(crate) use command::{
ToolsListCommand, ToolsOutcome, handle_tools_command,
};
pub(crate) use completion::{CompletionCommand, CompletionOutcome, handle_completion_command};
pub(crate) use logging::{
EVENT_FAILED, EVENT_LEVEL_APPLIED, EVENT_REJECTED, EVENT_SERVED, INVALID_LEVEL, LogLevel,
LogLevelStore, LoggingOutcome, SetLevelCommand, handle_logging_command, modern_request_level,
note, scoped as logging_scope, set_active_level, set_sse_acceptable, take_notifications,
};
pub(crate) use prompts::{
PromptGetCommand, PromptsCommand, PromptsListCommand, PromptsOutcome, handle_prompts_command,
};
@@ -22,15 +22,6 @@ pub(crate) enum CapabilityId {
Prompts,
/// Bounded argument completion for bound Published Prompts and Resource templates (Story 3.17).
Completions,
/// `logging` server capability: safe structured `notifications/message` events of the negotiated
/// client context (Story 3.18). Advertised in both revisions; the pinned modern revision carries
/// the level per request in `_meta` and marks the capability deprecated (SEP-2577).
Logging,
/// `logging/setLevel` as the *legacy* client request that sets a session level. It is a
/// dispatch-only registration without an advertisement fragment because the pinned modern
/// revision has no such method: there the per-request `_meta` key replaces it, so the same wire
/// name is a wrong-era request and must never be served.
LoggingSetLevel,
Ping,
Discovery,
LegacyLifecycle,
@@ -90,10 +81,6 @@ pub(crate) enum MethodHandler {
/// `completion/complete`: bounded suggestions from the typed schema of one exact bound Prompt
/// argument or one exact bound Resource template parameter (Story 3.17).
Completion,
/// `logging/setLevel`: validate the pinned level and record it for this legacy session, so the
/// adapter can deliver safe structured `notifications/message` events of that context
/// (Story 3.18). The handler never widens the accepted vocabulary and never echoes the input.
LoggingSetLevel,
Ping,
Discover,
Lifecycle,
@@ -395,33 +382,6 @@ pub(crate) const CAPABILITY_DESCRIPTORS: &[CapabilityIdDescriptor] = &[
advertised: Some(("completions", &[])),
revisions: MODERN_AND_LEGACY,
},
CapabilityIdDescriptor {
// Story 3.18: the standard `logging` declaration of both approved revisions. The pinned
// modern revision marks it deprecated (SEP-2577) but keeps it in the schema for at least
// twelve months, and `notifications/message` remains the only log channel there; the legacy
// revision additionally serves `logging/setLevel`.
id: CapabilityId::Logging,
roster: Roster::Server,
kind: Kind::Capability,
extension: None,
deprecated: None,
// The pinned schema declares `logging` as an open object with no named sub-features.
sub_features: FeatureSet(&[]),
advertised: Some(("logging", &[])),
revisions: MODERN_AND_LEGACY,
},
CapabilityIdDescriptor {
// Dispatch-only registration of the legacy `logging/setLevel` request: it is a client
// request, not an advertised server capability, and it does not exist in the modern schema.
id: CapabilityId::LoggingSetLevel,
roster: Roster::Server,
kind: Kind::Method,
extension: None,
deprecated: None,
sub_features: FeatureSet(&[]),
advertised: None,
revisions: LEGACY_ONLY,
},
CapabilityIdDescriptor {
id: CapabilityId::Ping,
roster: Roster::Server,
@@ -526,16 +486,6 @@ pub(crate) const METHOD_DESCRIPTORS: &[MethodDescriptor] = &[
required_headers: HEADERS_METHOD_ONLY,
handler: MethodHandler::Completion,
},
MethodDescriptor {
// Story 3.18: the legacy client request that sets the log level of its session. It declares
// the level, not a server-side name, so only the method header applies; the pinned modern
// revision has no such method at all (per-request `_meta` replaces it).
name: "logging/setLevel",
capability: CapabilityId::LoggingSetLevel,
kind: Kind::Method,
required_headers: HEADERS_METHOD_ONLY,
handler: MethodHandler::LoggingSetLevel,
},
MethodDescriptor {
name: "ping",
capability: CapabilityId::Ping,
@@ -36,7 +36,6 @@ fn static_registration_is_unique_and_advertises_only_the_registered_capability()
registry.advertised_capabilities(revision),
json!({
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -47,7 +46,6 @@ fn static_registration_is_unique_and_advertises_only_the_registered_capability()
advertised_server_capabilities(revision),
json!({
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -261,7 +259,6 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
without.advertised_capabilities(MODERN_PROTOCOL_VERSION),
json!({
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -272,7 +269,6 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
json!({
"inert_test_capability": {"enabled": true},
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -283,7 +279,6 @@ fn an_inert_test_descriptor_changes_both_projections_and_is_never_registered_in_
json!({
"inert_test_capability": {"enabled": true},
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -467,7 +462,6 @@ fn a_single_era_descriptor_never_leaks_into_the_other_era_advertisement() {
other_era_advertisement,
json!({
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
@@ -660,56 +654,6 @@ fn story317_completion_is_advertised_and_dispatchable_in_both_revisions() {
);
}
#[test]
fn story318_logging_is_advertised_on_both_revisions_and_set_level_is_legacy_only() {
let registry = production_registry();
for revision in [MODERN_PROTOCOL_VERSION, LEGACY_PROTOCOL_VERSION] {
assert!(
registry.advertise_for(CapabilityId::Logging, revision),
"the implemented logging surface must be advertised in {revision}"
);
assert_eq!(
registry.advertised_capabilities(revision)["logging"],
json!({}),
"the pinned advertisement is an empty `logging` object in {revision}"
);
}
// `logging/setLevel` is a legacy request only: the pinned modern revision replaces it with the
// per-request `_meta` log level, so the modern era must never serve it.
assert_eq!(
registry.dispatch_decision("logging/setLevel", LEGACY_PROTOCOL_VERSION),
DispatchDecision::Allowed {
handler: MethodHandler::LoggingSetLevel,
kind: Kind::Method,
}
);
assert_eq!(
registry.dispatch_decision("logging/setLevel", MODERN_PROTOCOL_VERSION),
DispatchDecision::WrongEra {
handler: MethodHandler::LoggingSetLevel,
kind: Kind::Method,
},
"a method the modern schema does not declare must never reach a handler there"
);
let descriptor = METHOD_DESCRIPTORS
.iter()
.find(|descriptor| descriptor.name == "logging/setLevel")
.expect("logging/setLevel is a registered method");
assert_eq!(
descriptor.required_headers.0,
&["Mcp-Method"],
"the request declares a level, not a server-side name"
);
assert!(
CAPABILITY_DESCRIPTORS
.iter()
.filter(|descriptor| descriptor.id == CapabilityId::LoggingSetLevel)
.all(|descriptor| descriptor.advertised.is_none()),
"the client request must never be advertised as a server capability"
);
}
#[test]
fn adding_and_removing_a_method_descriptor_changes_the_dispatch_decision() {
// The inert capability owns one inert method. With the method descriptor registered the
@@ -758,7 +702,6 @@ fn adding_and_removing_a_method_descriptor_changes_the_dispatch_decision() {
json!({
"inert_test_capability": {"enabled": true},
"completions": {},
"logging": {},
"prompts": {"listChanged": false},
"resources": {"listChanged": false, "subscribe": false},
"tools": {"listChanged": false}
+1 -56
View File
@@ -116,19 +116,6 @@ fn accepted_media_types(headers: &HeaderMap) -> Option<Vec<String>> {
)
}
/// Whether this request offered `text/event-stream`.
///
/// Story 3.18: the SSE response stream is the only carrier of a server `notifications/message`, so
/// the logging projection asks this before it promises a notification. It is the same admission rule
/// the response-mode negotiation already applies, not a second interpretation of the header.
pub(super) fn accepts_event_stream(headers: &HeaderMap) -> bool {
accepted_media_types(headers).is_some_and(|media_types| {
media_types
.iter()
.any(|media_type| media_type == "text/event-stream")
})
}
pub(super) fn negotiate_post_response_mode(
headers: &HeaderMap,
) -> Result<ResponseMode, StatusCode> {
@@ -279,26 +266,8 @@ pub(super) fn transport_response(
protocol_version: Option<&str>,
) -> Response {
let outcome = payload_outcome(&payload);
// Story 3.18: this is the single projection point of the adapter's own safe structured event.
// The severity is derived from the already-decided outcome of the payload, so no request payload,
// credential, error cause or user value is read here.
note_logging_outcome(&payload);
let notifications = crate::protocol::take_notifications();
// A pending `notifications/message` has no carrier in a JSON body. When the client offered both
// media types and opted in to logging, the negotiated mode is the SSE stream, so the notification
// precedes the response instead of being silently dropped.
let response_mode = if notifications.is_empty() {
response_mode
} else {
ResponseMode::Sse
};
if status == StatusCode::OK && matches!(response_mode, ResponseMode::Sse) {
let mut messages = Vec::with_capacity(notifications.len() + 1);
for notification in notifications {
messages.push(Ok(Event::default().data(notification.to_string())));
}
messages.push(Ok(Event::default().data(payload.to_string())));
let stream = stream::iter(messages);
let stream = stream::iter([Ok(Event::default().data(payload.to_string()))]);
let mut response = sse_response(status, stream, session_id, protocol_version);
if let Some(outcome) = outcome {
@@ -310,30 +279,6 @@ pub(super) fn transport_response(
json_response(status, payload, session_id, protocol_version)
}
/// Record the closed safe event of one response: served, rejected as invalid, failed, or a tool-level
/// error. Every label is a fixed string of the closed vocabulary; nothing from the payload or the
/// request is copied into it.
fn note_logging_outcome(payload: &Value) {
use crate::protocol::{EVENT_FAILED, EVENT_REJECTED, EVENT_SERVED, LogLevel, note};
if payload.get("error").is_some() {
match payload.pointer("/error/code").and_then(Value::as_i64) {
// The pinned client-error codes of a malformed request.
Some(-32600 | -32602) => note(LogLevel::Warning, EVENT_REJECTED, "invalid_params"),
_ => note(LogLevel::Error, EVENT_FAILED, "internal"),
}
return;
}
if payload
.pointer("/result/isError")
.and_then(Value::as_bool)
.unwrap_or(false)
{
note(LogLevel::Warning, EVENT_REJECTED, "tool_error");
return;
}
note(LogLevel::Info, EVENT_SERVED, "ok");
}
fn payload_outcome(payload: &Value) -> Option<McpOutcome> {
if payload.get("error").is_some() {
return Some(McpOutcome::JsonRpcError);
+1 -1
View File
@@ -3,7 +3,7 @@
{
"kind": "inventory",
"path": "docs/capability-inventory.json",
"sha256": "85970569edd1b658a6cea4444c796efabe166a6833787c7e98249f20a1eaf29d"
"sha256": "96589e25b7a3247f633fba2b031910e2ed4355d9ce8d29c7641638217800de0d"
},
{
"kind": "required_surfaces",
+10 -12
View File
@@ -884,28 +884,26 @@
"surface": "experimental"
},
{
"advertised": {
"logging": {}
},
"advertised": null,
"applicability": "stable",
"evidence_target": "logging",
"fallback": "capability not advertised, request not dispatched",
"kind": "capability",
"open_subfeatures": false,
"owner": "community-release",
"owner": "story 3.18",
"per_revision": {
"2026-07-28": {
"applicability": "deprecated"
}
},
"reason": "safe MCP server logging is implemented (Story 3.18, FR-19); the capability is deprecated in the pinned 2026-07-28 revision, where the per-request `_meta` log level replaces logging/setLevel, and present in the legacy revision, where logging/setLevel is served",
"reason": "safe MCP server logging is owned by story 3.18 (FR-19); the capability is deprecated in the pinned 2026-07-28 revision and remains present in the legacy revision",
"requirement": "FR-19",
"revisions": [
"2026-07-28",
"2025-11-25"
],
"role": "server",
"status": "supported",
"status": "deferred",
"subfeatures": [],
"surface": "logging"
},
@@ -1368,14 +1366,14 @@
"fallback": "capability not advertised, request not dispatched",
"kind": "method",
"open_subfeatures": false,
"owner": "community-release",
"reason": "served in the legacy revision by Story 3.18 (FR-19): the level is validated against the pinned LoggingLevel union and recorded for the client session; the pinned modern revision replaces this method with the per-request `_meta` log level, so the same wire name is a wrong-era request there",
"owner": "story 3.18",
"reason": "safe MCP server logging is owned by story 3.18 (FR-19); the pinned modern revision replaces this method with a per-request log level",
"requirement": "FR-19",
"revisions": [
"2025-11-25"
],
"role": "client",
"status": "supported",
"status": "deferred",
"subfeatures": [],
"surface": "logging/setLevel"
},
@@ -1694,20 +1692,20 @@
"fallback": "capability not advertised, request not dispatched",
"kind": "notification",
"open_subfeatures": false,
"owner": "community-release",
"owner": "story 3.18",
"per_revision": {
"2026-07-28": {
"applicability": "deprecated"
}
},
"reason": "emitted by the adapter since Story 3.18 (FR-19) from a closed safe vocabulary only; still declared (deprecated) in the pinned 2026-07-28 revision, where a request opts in through `_meta`",
"reason": "safe MCP server logging is owned by story 3.18 (FR-19); the notification is deprecated in the pinned 2026-07-28 revision, where a request opts in per request",
"requirement": "FR-19",
"revisions": [
"2026-07-28",
"2025-11-25"
],
"role": "server",
"status": "supported",
"status": "deferred",
"subfeatures": [],
"surface": "notifications/message"
},
-50
View File
@@ -1,50 +0,0 @@
# Проверки в CI
## Уровни
Обычная story запускает быстрые статические и контрактные проверки затронутого
проекта плюс один явный ATDD-вход `scripts/ci-story-checks.sh`. Скрипт содержит
короткие команды для принятого восстановительного scope и завершается ошибкой,
если команда падает или не выбрала ни одного теста. Story CI не запускает полный
Rust workspace, полный pytest, browser E2E, образный smoke или feature matrix.
Полная проверка фичи запускается при ручном `workflow_dispatch` с
`validation_level: feature` или PR с меткой `feature-ready`. Снятие метки,
обычный push и обычный PR возвращают CI к уровню story. Стабильный обязательный
контекст слияния — `CI / Required Checks`; он всегда проверяет базовые jobs, а
feature jobs должны быть `skipped` для story и `success` для feature. Пустой или
неизвестный результат считается ошибкой.
У Crank и FreeHub полный Rust clippy/workspace test и тяжёлые feature/security
проверки выполняются только на feature. UI build и быстрые UI unit tests остаются
на story, Playwright E2E — на feature. Crank image build/scan/compose smoke — на
feature; фактический Deploy остаётся отдельным push-main job со своими build,
scan, health и требованием успешного SHA. Тег релиза по умолчанию запускает story
ATDD, сборку бинарных/UI артефактов, security audit и image scan. Полный release
clippy/workspace/E2E доступен через ручной dispatch с `validation_level: feature`;
отчёт evidence прикладывается только если такой E2E был выполнен. FreeHub
production CD сохраняет свой exact-SHA CI guard и собственные build/health
проверки.
У Torranslate story запускает один Python 3.14 и принятый целевой pytest файл;
feature запускает существующий Python 3.13/3.14 quality matrix и Docker Compose
smoke. Никакие workflow этого проекта не меняют Seerr, VPN/DNS или production.
## Поддержка ATDD-команд
Перед поставкой Dev и QA обновляют `scripts/ci-story-checks.sh` под story,
которая действительно поставляется. DevOps проверяет, что тот же проверяемый
коммит содержит актуальную команду. Начальные команды в этих скриптах относятся
к принятому recovery scope Crank 3.17, FreeHub 2.13 и Torranslate Phase0 sidecar;
они **не подтверждают**, что текущие 3.18, 2.14 или 1.19 уже проверены. Если
story требует security или contract regression, добавьте её точечно в тот же
вход и зафиксируйте основание в AC/handoff. Не добавляйте динамический selector,
список фильтров или общий тестовый framework.
## Стоимость и доказательства
Cargo registry/git и npm dependency caches уменьшают повторную загрузку
зависимостей. `target` не кешируется: холодная компиляция остаётся затратой и
не измерена этим изменением. Не заявляйте экономию времени до сравнения реальных
логов. Полный workspace/pytest и feature smoke назначаются для готовой фичи или
явного feature dispatch, а не каждой story.
-285
View File
@@ -1,285 +0,0 @@
#!/usr/bin/env python3
"""Publish immutable Crank release assets to Gitea, safely supporting retries."""
from __future__ import annotations
import hashlib
import json
import os
import re
import subprocess
import sys
import tempfile
from pathlib import Path
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode, urlsplit
from urllib.request import HTTPRedirectHandler, Request, build_opener
_REPO = re.compile(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+\Z")
_TAG = re.compile(r"v[A-Za-z0-9._+-]+\Z")
class PublishError(Exception):
"""Sanitized release publication failure safe to show in CI logs."""
class _NoRedirect(HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
raise PublishError(
f"Gitea API redirected (HTTP {code}); refusing to forward credentials"
)
def _inputs(env):
raw_base = env.get("GITEA_SERVER_URL", "")
parts = urlsplit(raw_base)
if (
parts.scheme != "https"
or not parts.hostname
or parts.username
or parts.password
or parts.query
or parts.fragment
or parts.path not in ("", "/")
):
raise PublishError("GITEA_SERVER_URL must be the trusted HTTPS Gitea origin")
repo = env.get("GITEA_REPOSITORY", "")
if not _REPO.fullmatch(repo):
raise PublishError("GITEA_REPOSITORY must be owner/repository")
tag = env.get("RELEASE_TAG", "")
if not _TAG.fullmatch(tag):
raise PublishError("RELEASE_TAG is not a supported version tag")
token = env.get("GITEA_TOKEN", "")
if (
not token
or len(token) > 4096
or any(ord(char) < 32 or ord(char) == 127 for char in token)
):
raise PublishError("GITEA_TOKEN is unavailable or has invalid format")
origin = f"{parts.scheme}://{parts.netloc}"
owner, name = repo.split("/", 1)
api = f"{origin}/api/v1/repos/{quote(owner, safe='')}/{quote(name, safe='')}"
return origin, api, tag, token
def _json_request(opener, method, url, token, payload=None, allow_404=False):
body = None if payload is None else json.dumps(payload).encode("utf-8")
headers = {"Authorization": f"token {token}", "Accept": "application/json"}
if body is not None:
headers["Content-Type"] = "application/json"
request = Request(url, data=body, headers=headers, method=method)
try:
with opener.open(request, timeout=20) as response:
return json.loads(response.read()), response.status
except PublishError:
raise
except HTTPError as exc:
status = exc.code
exc.close()
if allow_404 and status == 404:
return None, 404
raise PublishError(f"Gitea release API request failed (HTTP {status})") from None
except (URLError, TimeoutError, OSError):
raise PublishError("Gitea release API request failed or timed out") from None
except (json.JSONDecodeError, UnicodeDecodeError):
raise PublishError("Gitea returned invalid release API data") from None
def _release_id(api, tag, token, opener):
tag_path = f"{api}/releases/tags/{quote(tag, safe='')}"
release, status = _json_request(opener, "GET", tag_path, token, allow_404=True)
if status == 404:
release, status = _json_request(
opener,
"POST",
f"{api}/releases",
token,
payload={
"tag_name": tag,
"name": f"Crank Community {tag}",
"body": "Checksums, evidence, and SBOM are attached to this release.",
},
)
if status not in (200, 201) or not isinstance(release, dict):
raise PublishError("Gitea did not return a release record")
if release.get("tag_name") != tag:
raise PublishError("Gitea returned a release for a different tag")
release_id = release.get("id")
if not isinstance(release_id, int) or release_id <= 0:
raise PublishError("Gitea returned an invalid release identifier")
return release_id
def _assets(api, release_id, token, opener):
collected = {}
page_size = 50
max_pages = 20
for page_num in range(1, max_pages + 1):
url = f"{api}/releases/{release_id}/assets?{urlencode({'page': page_num, 'limit': page_size})}"
result, status = _json_request(opener, "GET", url, token)
if status != 200 or not isinstance(result, list):
raise PublishError("Gitea returned invalid release asset data")
for item in result:
if (
not isinstance(item, dict)
or not isinstance(item.get("name"), str)
or not isinstance(item.get("id"), int)
or not isinstance(item.get("size"), int)
or not isinstance(item.get("browser_download_url"), str)
):
raise PublishError("Gitea returned a malformed release asset")
if item["name"] in collected:
raise PublishError(
f"Gitea returned duplicate release asset name {item['name']}"
)
collected[item["name"]] = item
if len(result) < page_size:
return collected
raise PublishError("Gitea release asset history exceeded the pagination limit")
def _same_bytes(origin, attachment, local_path, token, opener):
download = urlsplit(attachment["browser_download_url"])
trusted = urlsplit(origin)
if (
download.scheme != "https"
or download.netloc != trusted.netloc
or download.username
or download.password
or download.fragment
):
raise PublishError(
f"Existing asset {attachment['name']} has an untrusted download URL; refusing to replace it"
)
expected_size = local_path.stat().st_size
if attachment["size"] != expected_size:
return False
request = Request(
attachment["browser_download_url"],
headers={"Authorization": f"token {token}"},
)
try:
with opener.open(request, timeout=30) as response:
digest = hashlib.sha256()
total = 0
while True:
chunk = response.read(1024 * 1024)
if not chunk:
break
total += len(chunk)
if total > expected_size:
return False
digest.update(chunk)
except PublishError:
raise
except HTTPError as exc:
status = exc.code
exc.close()
if 300 <= status < 400:
raise PublishError(
f"Existing asset {attachment['name']} redirects; refusing to forward credentials"
) from None
raise PublishError(
f"Could not compare existing release asset (HTTP {status})"
) from None
except (URLError, TimeoutError, OSError):
raise PublishError("Could not download existing release asset for comparison") from None
return total == expected_size and digest.digest() == _hash_file(local_path)
def _hash_file(path):
digest = hashlib.sha256()
with path.open("rb") as source:
for chunk in iter(lambda: source.read(1024 * 1024), b""):
digest.update(chunk)
return digest.digest()
def _curl_config(token):
escaped = token.replace("\\", "\\\\").replace('"', '\\"')
config = tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False)
try:
config.write(f'header = "Authorization: token {escaped}"\n')
config.flush()
os.chmod(config.name, 0o600)
return config.name
finally:
config.close()
def _upload(api, release_id, path, token):
name = path.name
url = f"{api}/releases/{release_id}/assets?{urlencode({'name': name})}"
auth_config = _curl_config(token)
try:
result = subprocess.run(
[
"curl",
"--fail",
"--silent",
"--show-error",
"--max-time",
"180",
"--config",
auth_config,
"-F",
f"attachment=@{path}",
url,
],
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
except OSError:
raise PublishError("curl is unavailable for release asset upload") from None
finally:
Path(auth_config).unlink(missing_ok=True)
if result.returncode != 0:
raise PublishError(f"Gitea rejected release asset {name} (curl exit {result.returncode})")
def publish(env=None, assets=None, opener=None, upload=_upload):
env = os.environ if env is None else env
origin, api, tag, token = _inputs(env)
if not assets:
raise PublishError("No release assets were provided")
paths = [Path(item) for item in assets]
if any(not path.is_file() for path in paths):
raise PublishError("A requested release asset file is missing")
names = [path.name for path in paths]
if len(names) != len(set(names)):
raise PublishError("Release asset names must be unique")
opener = opener or build_opener(_NoRedirect())
release_id = _release_id(api, tag, token, opener)
existing = _assets(api, release_id, token, opener)
published = []
for path in paths:
attachment = existing.get(path.name)
if attachment is not None:
if not _same_bytes(origin, attachment, path, token, opener):
raise PublishError(
f"Release asset {path.name} already exists with different bytes; immutable asset left unchanged"
)
published.append((path.name, "already present with matching bytes"))
continue
upload(api, release_id, path, token)
published.append((path.name, "uploaded"))
return {"tag": tag, "release_id": release_id, "assets": published}
def main(argv=None):
argv = sys.argv[1:] if argv is None else argv
try:
result = publish(assets=argv)
except PublishError as exc:
print(f"Gitea release assets: {exc}", file=sys.stderr)
return 1
print(f"Gitea release {result['tag']} (id {result['release_id']}):")
for name, state in result["assets"]:
print(f"{state}: {name}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
-35
View File
@@ -1,35 +0,0 @@
#!/usr/bin/env bash
set -euo pipefail
active_log=""
cleanup() {
if [[ -n "$active_log" ]]; then
rm -f -- "$active_log"
fi
}
trap cleanup EXIT
run_atdd() {
local description="$1"
shift
active_log="$(mktemp)"
if cargo test "$@" >"$active_log" 2>&1; then
if ! grep -Eq '^test result: ok\. [1-9][0-9]* passed' "$active_log"; then
cat "$active_log" >&2
printf 'ATDD command selected zero passing tests: %s\n' "$description" >&2
return 1
fi
grep '^test result:' "$active_log"
rm -f -- "$active_log"
active_log=""
return 0
fi
cat "$active_log" >&2
printf 'ATDD command failed: %s\n' "$description" >&2
return 1
}
# Initial accepted recovery scope for Crank Story 3.17. Update with the story
# being published and add only AC-required affected security/contract cases.
run_atdd "MCP completion" -p mcp-server --test integration mcp_completion -- --test-threads=1
run_atdd "static resource list" -p mcp-server --test integration static_resources::list -- --test-threads=1
+104
View File
@@ -0,0 +1,104 @@
#!/usr/bin/env python3
"""Attach the packaged release artifacts to the Gitea release of one tag.
The release workflow builds the archives, the checksums file and the SBOM into `dist/`; this script
is what makes them durable: it upserts the release entry of the tag and uploads every artifact to it,
so a published version keeps its artifacts and checksums after the runner workspace is gone.
The token is read from `GITEA_TOKEN` only; it is never printed, logged or written to disk.
"""
from __future__ import annotations
import argparse
import json
import mimetypes
import os
import sys
import urllib.error
import urllib.request
from pathlib import Path
TIMEOUT_SECONDS = 120
def _json(url: str, token: str, method: str = "GET", payload: dict | None = None) -> dict:
headers = {"Authorization": f"token {token}", "Accept": "application/json"}
data = None
if payload is not None:
data = json.dumps(payload).encode("utf-8")
headers["Content-Type"] = "application/json"
request = urllib.request.Request(url, data=data, headers=headers, method=method)
with urllib.request.urlopen(request, timeout=TIMEOUT_SECONDS) as response:
return json.loads(response.read() or b"{}")
def _upload(url: str, token: str, path: Path) -> dict:
headers = {
"Authorization": f"token {token}",
"Content-Type": mimetypes.guess_type(path.name)[0] or "application/octet-stream",
}
request = urllib.request.Request(url, data=path.read_bytes(), headers=headers, method="POST")
with urllib.request.urlopen(request, timeout=TIMEOUT_SECONDS) as response:
return json.loads(response.read() or b"{}")
def release_artifacts(dist: Path) -> list[Path]:
"""Every regular file directly in `dist/`, in a stable order; nested build dirs are ignored."""
return sorted(path for path in dist.iterdir() if path.is_file() and not path.name.startswith("."))
def publish(api: str, repo: str, tag: str, title: str, notes: Path, dist: Path, prerelease: bool, token: str) -> int:
base = f"{api.rstrip('/')}/repos/{repo}"
# The notes file is the release body, not an artifact of the release.
artifacts = [path for path in release_artifacts(dist) if path.name != notes.name]
if not artifacts:
print(f"no release artifacts in {dist}", file=sys.stderr)
return 2
try:
release = _json(f"{base}/releases/tags/{tag}", token)
except urllib.error.HTTPError as error:
if error.code != 404:
raise
release = _json(
f"{base}/releases",
token,
"POST",
{
"tag_name": tag,
"name": title,
"body": notes.read_text(encoding="utf-8"),
"draft": False,
"prerelease": prerelease,
},
)
existing = {asset["name"] for asset in release.get("assets") or []}
for path in artifacts:
if path.name in existing:
print(f"skip existing asset {path.name}")
continue
uploaded = _upload(f"{base}/releases/{release['id']}/assets?name={path.name}", token, path)
print(f"uploaded {path.name} -> {uploaded.get('browser_download_url', 'ok')}")
print(f"release {tag} id={release['id']} artifacts={len(artifacts)}")
return 0
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--api", required=True, help="API root, e.g. https://git.itexp.me/api/v1")
parser.add_argument("--repo", required=True, help="owner/name")
parser.add_argument("--tag", required=True)
parser.add_argument("--title", required=True)
parser.add_argument("--notes-file", type=Path, required=True)
parser.add_argument("--dist", type=Path, required=True)
parser.add_argument("--prerelease", action="store_true")
args = parser.parse_args()
token = os.environ.get("GITEA_TOKEN", "")
if not token:
print("GITEA_TOKEN is required to publish release artifacts", file=sys.stderr)
return 2
return publish(args.api, args.repo, args.tag, args.title, args.notes_file, args.dist, args.prerelease, token)
if __name__ == "__main__":
raise SystemExit(main())
@@ -1 +1 @@
{"completions":{},"logging":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}
{"completions":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}
@@ -1,14 +1,9 @@
{
"revision": "2025-11-25",
"inventory_path": "docs/capability-inventory.json",
"inventory_sha256": "85970569edd1b658a6cea4444c796efabe166a6833787c7e98249f20a1eaf29d",
"inventory_sha256": "96589e25b7a3247f633fba2b031910e2ed4355d9ce8d29c7641638217800de0d",
"rule": "remaining-ac-spec.md#5-server-only-projection-rules-1-4",
"projection_inputs": [
{
"role": "server",
"kind": "capability",
"surface": "logging"
},
{
"role": "server",
"kind": "capability",
@@ -1 +1 @@
{"completions":{},"logging":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}
{"completions":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}
@@ -1,14 +1,9 @@
{
"revision": "2026-07-28",
"inventory_path": "docs/capability-inventory.json",
"inventory_sha256": "85970569edd1b658a6cea4444c796efabe166a6833787c7e98249f20a1eaf29d",
"inventory_sha256": "96589e25b7a3247f633fba2b031910e2ed4355d9ce8d29c7641638217800de0d",
"rule": "remaining-ac-spec.md#5-server-only-projection-rules-1-4",
"projection_inputs": [
{
"role": "server",
"kind": "capability",
"surface": "logging"
},
{
"role": "server",
"kind": "capability",
@@ -1,10 +1,9 @@
{
"oracle": "crank-current-scope-advertised-capabilities",
"note": "Independent expected projection of the capability descriptor the CURRENT scope is allowed to advertise: advertisement equals what is implemented. Later capabilities are deferred and must not appear until their owning story implements them. This is a scoped projection, not the official MCP capability list.",
"expected_keys": ["completions", "logging", "prompts", "resources", "tools"],
"expected_keys": ["completions", "prompts", "resources", "tools"],
"expected_descriptor": {
"completions": {},
"logging": {},
"prompts": {
"listChanged": false
},
@@ -19,6 +18,7 @@
"must_not_be_advertised": ["experimental", "extensions"],
"deferred_with_owner": {
"change_signals": "story 3.19 (FR-19)",
"io.modelcontextprotocol/tasks": "story 4.7"
"io.modelcontextprotocol/tasks": "story 4.7",
"logging": "story 3.18 (FR-19)"
}
}
-245
View File
@@ -1,245 +0,0 @@
from __future__ import annotations
import json
import tempfile
import unittest
from importlib.util import module_from_spec, spec_from_file_location
from pathlib import Path
from urllib.error import HTTPError
_MODULE_SPEC = spec_from_file_location(
"ci_release_assets",
Path(__file__).parents[2] / "scripts" / "ci-release-assets.py",
)
release_assets = module_from_spec(_MODULE_SPEC)
_MODULE_SPEC.loader.exec_module(release_assets)
BASE = {
"GITEA_SERVER_URL": "https://git.example.test",
"GITEA_REPOSITORY": "team/project",
"RELEASE_TAG": "v1.2.3",
"GITEA_TOKEN": "gta_test-token",
}
API = "https://git.example.test/api/v1/repos/team/project"
class Response:
def __init__(self, payload=None, body=b"", status=200):
self.payload = payload
self.body = body
self.status = status
self.offset = 0
def __enter__(self):
return self
def __exit__(self, *_args):
return False
def read(self, size=-1):
if self.payload is not None:
body = json.dumps(self.payload).encode()
else:
body = self.body
if size < 0:
chunk = body[self.offset :]
self.offset = len(body)
return chunk
chunk = body[self.offset : self.offset + size]
self.offset += len(chunk)
return chunk
class Opener:
def __init__(self, results):
self.results = list(results)
self.requests = []
def open(self, request, timeout):
self.requests.append((request, timeout))
if not self.results:
raise AssertionError(f"unexpected HTTP request: {request.full_url}")
expected_method, expected_fragment, result = self.results.pop(0)
self_method = request.get_method()
if self_method != expected_method or expected_fragment not in request.full_url:
raise AssertionError(
f"unexpected request {self_method} {request.full_url}; "
f"expected {expected_method} containing {expected_fragment}"
)
if isinstance(result, BaseException):
raise result
return result
def api_error(status):
return HTTPError("https://git.example.test/api", status, "error", {}, None)
def release_record():
return {"id": 17, "tag_name": "v1.2.3"}
def asset_record(name, content, url="https://git.example.test/download/file"):
return {"id": 8, "name": name, "size": len(content), "browser_download_url": url}
class ReleaseAssetsTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.path = Path(self.temp.name) / "bundle.tar.gz"
self.path.write_bytes(b"expected release bytes")
self.uploads = []
def tearDown(self):
self.temp.cleanup()
def upload(self, api, release_id, path, token):
self.uploads.append((api, release_id, path.name, token))
def test_creates_release_and_uploads_missing_asset(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", api_error(404)),
("POST", "/releases", Response(payload=release_record(), status=201)),
("GET", "/releases/17/assets", Response(payload=[])),
]
)
result = release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(result["release_id"], 17)
self.assertEqual(result["assets"], [("bundle.tar.gz", "uploaded")])
self.assertEqual(len(self.uploads), 1)
self.assertEqual(opener.requests[1][0].get_method(), "POST")
self.assertEqual(opener.requests[1][0].get_header("Authorization"), "token gta_test-token")
def test_rerun_reuses_tag_release_and_skips_matching_asset_bytes(self):
expected = self.path.read_bytes()
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, expected)]),
),
("GET", "/download/file", Response(body=expected)),
]
)
result = release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(result["assets"], [("bundle.tar.gz", "already present with matching bytes")])
self.assertEqual(self.uploads, [])
self.assertEqual([request.get_method() for request, _ in opener.requests], ["GET", "GET", "GET"])
def test_partial_retry_skips_matching_asset_and_uploads_only_missing_asset(self):
second = Path(self.temp.name) / "checksums.txt"
second.write_bytes(b"checksums")
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, self.path.read_bytes())]),
),
("GET", "/download/file", Response(body=self.path.read_bytes())),
]
)
result = release_assets.publish(
BASE, [str(self.path), str(second)], opener, self.upload
)
self.assertEqual(
result["assets"],
[
("bundle.tar.gz", "already present with matching bytes"),
("checksums.txt", "uploaded"),
],
)
self.assertEqual(len(self.uploads), 1)
self.assertEqual(self.uploads[0][2], "checksums.txt")
def test_different_existing_asset_is_not_overwritten(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, b"x" * self.path.stat().st_size)]),
),
("GET", "/download/file", Response(body=b"x" * self.path.stat().st_size)),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "different bytes"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(self.uploads, [])
def test_untrusted_existing_asset_url_is_rejected(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(
payload=[
asset_record(
self.path.name,
self.path.read_bytes(),
"https://evil.example/download",
)
]
),
),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "untrusted download URL"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
self.assertEqual(self.uploads, [])
self.assertEqual(len(opener.requests), 2)
def test_same_size_different_bytes_fail(self):
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, b"x" * self.path.stat().st_size)]),
),
("GET", "/download/file", Response(body=b"x" * self.path.stat().st_size)),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "different bytes"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
def test_redirected_asset_download_fails_without_forwarding_token(self):
redirect = HTTPError(
"https://git.example.test/download/file",
302,
"Found",
{"Location": "https://evil.example/file"},
None,
)
opener = Opener(
[
("GET", "/releases/tags/v1.2.3", Response(payload=release_record())),
(
"GET",
"/releases/17/assets",
Response(payload=[asset_record(self.path.name, self.path.read_bytes())]),
),
("GET", "/download/file", redirect),
]
)
with self.assertRaisesRegex(release_assets.PublishError, "redirects"):
release_assets.publish(BASE, [str(self.path)], opener, self.upload)
download_request = opener.requests[-1][0]
self.assertEqual(download_request.get_header("Authorization"), "token gta_test-token")
self.assertEqual(self.uploads, [])
def test_invalid_token_header_characters_are_rejected(self):
with self.assertRaisesRegex(release_assets.PublishError, "invalid format"):
release_assets.publish({**BASE, "GITEA_TOKEN": "bad\ntoken"}, [str(self.path)], Opener([]), self.upload)
if __name__ == "__main__":
unittest.main()
@@ -47,12 +47,13 @@ EXPECTED_FROZEN = (
b'{"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}'
)
EXPECTED_SHA256 = "e38c795fc28fee74168cb045427df55d882f8f7ace206af5c9a3ca4df5892c9a"
# The canonical inventory also implements the logging surface (Story 3.18, FR-19), so the committed
# oracle and the canonical projection carry `logging` next to `completions`/`prompts`/`resources`/`tools`.
# The canonical inventory implements the completions/prompts/resources/tools surfaces, so the committed
# oracle and the canonical projection carry exactly those four; the logging surface is still deferred
# to its owning story and must not appear in the advertisement.
COMMITTED_FROZEN = (
b'{"completions":{},"logging":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}'
b'{"completions":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}'
)
COMMITTED_SHA256 = "f806e750402d418b8a3784eff200338cd8fd91b69c2f99e9d564cb08217b84d2"
COMMITTED_SHA256 = "08c29e3df2bd8ffc58c1ec172714cc06031c5b279ef042940a8591940aca91fe"
class AdvertisedCapabilitiesProjectionTests(unittest.TestCase):
@@ -293,7 +294,6 @@ class AdvertisedCapabilitiesProjectionTests(unittest.TestCase):
),
[
("server", "capability", "completions"),
("server", "capability", "logging"),
("server", "capability", "prompts"),
("server", "capability", "resources"),
("server", "capability", "tools"),
@@ -332,7 +332,6 @@ class CommittedFrozenOracleTests(unittest.TestCase):
),
[
("server", "capability", "completions"),
("server", "capability", "logging"),
("server", "capability", "prompts"),
("server", "capability", "resources"),
("server", "capability", "tools"),
+138
View File
@@ -0,0 +1,138 @@
"""AT-3 (release durability): the artifacts of a tag land on the Gitea release, idempotently."""
from __future__ import annotations
import contextlib
import importlib.util
import io
import json
import sys
import tempfile
import threading
import unittest
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
SCRIPT = ROOT / "scripts" / "publish-gitea-release.py"
def load_module():
spec = importlib.util.spec_from_file_location("publish_gitea_release", SCRIPT)
assert spec is not None and spec.loader is not None
module = importlib.util.module_from_spec(spec)
sys.modules[spec.name] = module
spec.loader.exec_module(module)
return module
class Stub:
def __init__(self) -> None:
self.release_assets: list[dict] = []
self.created = False
self.uploaded: list[str] = []
self.created_payload: dict = {}
def handler(self):
stub = self
class Handler(BaseHTTPRequestHandler):
def log_message(self, format, *args): # noqa: A002 - base class signature
return
def _reply(self, status: int, payload: dict) -> None:
body = json.dumps(payload).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self):
if self.path.endswith("/releases/tags/v1.2.3") and stub.created:
self._reply(200, {"id": 7, "assets": stub.release_assets})
else:
self._reply(404, {"message": "not found"})
def do_POST(self):
length = int(self.headers.get("Content-Length") or 0)
body = self.rfile.read(length)
if self.path.endswith("/releases"):
stub.created = True
stub.created_payload = json.loads(body)
self._reply(201, {"id": 7, "assets": []})
return
if "/releases/7/assets?name=" in self.path:
name = self.path.rsplit("name=", 1)[1]
stub.uploaded.append(name)
stub.release_assets.append(
{"name": name, "browser_download_url": f"http://stub/assets/{name}"}
)
self._reply(201, {"name": name, "browser_download_url": f"http://stub/assets/{name}"})
return
self._reply(404, {"message": "not found"})
return Handler
class PublishGiteaReleaseTests(unittest.TestCase):
def setUp(self) -> None:
self.module = load_module()
self.stub = Stub()
self.server = ThreadingHTTPServer(("127.0.0.1", 0), self.stub.handler())
self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
self.thread.start()
self.api = f"http://127.0.0.1:{self.server.server_address[1]}"
self.tmp = tempfile.TemporaryDirectory()
self.dist = Path(self.tmp.name)
(self.dist / "crank-community-admin-api-v1.2.3.tar.gz").write_bytes(b"admin")
(self.dist / "crank-community-v1.2.3-checksums.txt").write_text("deadbeef admin.tar.gz\n")
(self.dist / "nested").mkdir()
(self.dist / "nested" / "admin-api").write_bytes(b"raw")
self.notes = self.dist / "RELEASE-NOTES.md"
self.notes.write_text("## v1.2.3\n", encoding="utf-8")
def tearDown(self) -> None:
self.server.shutdown()
self.server.server_close()
self.tmp.cleanup()
def publish(self) -> tuple[int, str]:
output = io.StringIO()
with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
code = self.module.publish(
self.api,
"bsodfather/crank",
"v1.2.3",
"Crank Community v1.2.3",
self.notes,
self.dist,
True,
"stub-token-never-printed",
)
return code, output.getvalue()
def test_release_is_created_with_notes_and_every_top_level_artifact(self) -> None:
code, output = self.publish()
self.assertEqual(code, 0, output)
self.assertEqual(self.stub.created_payload["tag_name"], "v1.2.3")
self.assertTrue(self.stub.created_payload["prerelease"])
self.assertEqual(self.stub.created_payload["body"], "## v1.2.3\n")
self.assertEqual(
self.stub.uploaded,
["crank-community-admin-api-v1.2.3.tar.gz", "crank-community-v1.2.3-checksums.txt"],
"every top-level artifact and nothing from the nested build dir",
)
self.assertNotIn("stub-token-never-printed", output, "the token must never reach the log")
def test_second_run_reuses_the_release_and_skips_existing_assets(self) -> None:
self.assertEqual(self.publish()[0], 0)
uploaded_first = list(self.stub.uploaded)
code, output = self.publish()
self.assertEqual(code, 0, output)
self.assertEqual(self.stub.uploaded, uploaded_first, "a rerun must not upload duplicates")
self.assertEqual(output.count("skip existing asset"), 2, output)
if __name__ == "__main__":
unittest.main()
@@ -1276,9 +1276,9 @@ class Story31FoundationProjectionBoundaryTests(unittest.TestCase):
"""
EXPECTED_FROZEN = (
b'{"completions":{},"logging":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}'
b'{"completions":{},"prompts":{"listChanged":false},"resources":{"listChanged":false,"subscribe":false},"tools":{"listChanged":false}}'
)
EXPECTED_FROZEN_SHA256 = "f806e750402d418b8a3784eff200338cd8fd91b69c2f99e9d564cb08217b84d2"
EXPECTED_FROZEN_SHA256 = "08c29e3df2bd8ffc58c1ec172714cc06031c5b279ef042940a8591940aca91fe"
def test_control_committed_frozen_oracle_is_the_canonical_projection(self) -> None:
"""Positive control (existing GREEN, AT-13): the committed frozen bytes are canonical."""