Compare commits

...
Author SHA1 Message Date
bsodfather 7f18bce679 feat(mcp): route Tools requests through typed rmcp runtime seam
CI / Rust Checks (pull_request) Successful in 24m17s
CI / Rust Feature Validation (pull_request) Skipped
CI / UI Checks (pull_request) Successful in 7s
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 15:00:22 +00:00
bsodfather 4ec9d9201b Merge pull request 'Use verified Trivy runner cache and avoid Cargo builds for release-only fixes' (#118) from fix/trivy-runner-cache-20261108 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Failing after 1h39m35s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Failing after 1s
CI / Deploy (push) Skipped
2026-11-08 12:26:19 +00:00
bsodfather cf2909273b perf(ci): scope release tooling changes without unrelated Cargo builds
CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 24m39s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 14:47:35 +03:00
bsodfather 4a7b230f35 fix(ci): load checksum-verified Trivy from runner tool cache 2026-11-08 14:21:16 +03:00
bsodfather cfe11a0a04 Merge pull request 'fix(ci): download pinned Trivy asset through GitHub API on HTTP failure' (#117) from fix/trivy-asset-api-20261108 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Failing after 17m52s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Failing after 2s
CI / Deploy (push) Skipped
2026-11-08 10:59:43 +00:00
bsodfather 35a21f8ab5 fix(ci): fall back to pinned GitHub asset API for Trivy
CI / UI Checks (pull_request) Successful in 11s
CI / Rust Checks (pull_request) Successful in 25m14s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
2026-11-08 13:02:56 +03:00
bsodfather 2d0deb8963 Merge pull request 'fix(ci): download Trivy database from reachable official registry' (#116) from fix/release-db-source-20261107 into main
CI / UI Checks (push) Successful in 14s
CI / Rust Checks (push) Successful in 25m23s
CI / Rust Feature Validation (push) Skipped
CI / Frontend E2E (push) Skipped
CI / Community Image Smoke (push) Skipped
CI / Required Checks (push) Successful in 1s
CI / Deploy (push) Skipped
2026-11-08 09:40:01 +00:00
14 changed files with 816 additions and 18 deletions

No files matched your search

+13
View File
@@ -40,6 +40,15 @@ jobs:
with:
fetch-depth: 0
- name: Detect release-tooling-only changes
id: release_tooling
env:
GITEA_EVENT_NAME: ${{ gitea.event_name }}
GITEA_EVENT_BEFORE: ${{ gitea.event.before }}
GITEA_PR_BASE_SHA: ${{ gitea.event.pull_request.base.sha }}
FORCE_FULL: ${{ inputs.validation_level == 'feature' || contains(gitea.event.pull_request.labels.*.name, 'feature-ready') }}
run: python3 scripts/ci-release-tooling-scope.py
- name: Install Rust toolchain
run: |
set -eu
@@ -78,15 +87,18 @@ jobs:
docker info
- name: Check typed runtime configuration contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: |
cargo run -p crank-config --bin crank-config-contract -- --check
python3 scripts/check-runtime-config.py --root .
python3 scripts/check-config-boundaries.py --root .
- name: Check canonical migration contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: cargo run -p admin-api --bin crank-migrate -- plan --check
- name: Check typed metrics contract
if: steps.release_tooling.outputs.ci_only != 'true'
run: |
cargo run -p crank-metrics --bin crank-metrics-contract -- --check
python3 scripts/check-metrics-boundaries.py --root .
@@ -142,6 +154,7 @@ jobs:
python3 scripts/check-openapi-matrix-compatibility.py --base "$base_ref"
- name: Run Crank story ATDD
if: steps.release_tooling.outputs.ci_only != 'true'
run: scripts/ci-story-checks.sh
ui:
name: UI Checks
+3
View File
@@ -32,6 +32,9 @@ tokio = { workspace = true, features = ["sync"] }
tracing.workspace = true
uuid.workspace = true
# Typed Tools dispatch uses the SDK; its HTTP transport remains test-only.
rmcp = { version = "=3.7.0" }
[dev-dependencies]
rmcp = { version = "=3.7.0", features = ["transport-streamable-http-server"] }
crank-mapping = { path = "../crank-mapping" }
+1
View File
@@ -34,6 +34,7 @@ pub(crate) mod lifecycle;
mod metrics;
mod request;
mod response;
mod rmcp_dispatch;
#[cfg(test)]
mod rmcp_http;
#[cfg(test)]
@@ -7,6 +7,7 @@
use super::request::{InitializeParams, ToolCallParams};
use super::response::take_confirmation_token;
use super::rmcp_dispatch::handle_tools_command;
use crate::{
auth::VerifiedMachineCredential,
jsonrpc::{
@@ -19,7 +20,7 @@ use crate::{
ResourceReadCommand, ResourcesCommand, ResourcesListCommand, ResourcesOutcome,
ServiceContext, ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome,
declared_mcp_method, discover_result, handle_completion_command, handle_prompts_command,
handle_resources_command, handle_tools_command, validate_modern_request_name,
handle_resources_command, validate_modern_request_name,
},
session::SessionState,
tool_error::execution_locale,
@@ -51,9 +51,15 @@ pub(crate) struct CounterSet {
era_modern: AtomicUsize,
era_legacy: AtomicUsize,
tools_service: AtomicUsize,
sdk_tools_dispatch: AtomicUsize,
}
impl CounterSet {
/// SDK typed Tools dispatch entries, separate from the existing era/service snapshot.
pub(crate) fn sdk_tools_dispatch(&self) -> usize {
self.sdk_tools_dispatch.load(Ordering::SeqCst)
}
/// Read the counters of one observed request as one comparable snapshot.
pub(crate) fn snapshot(&self) -> Snapshot {
Snapshot {
@@ -134,6 +140,11 @@ pub(crate) fn tools_service_enter() {
increment(|counters| &counters.tools_service);
}
/// `SDK_TOOLS_DISPATCH`: entered the real SDK typed Tools dispatch, not just admission.
pub(crate) fn sdk_tools_dispatch_enter() {
increment(|counters| &counters.sdk_tools_dispatch);
}
fn increment(counter: impl Fn(&CounterSet) -> &AtomicUsize) {
let _ = OBSERVER.try_with(|counters| {
counter(counters).fetch_add(1, Ordering::SeqCst);
@@ -153,3 +164,7 @@ pub(crate) mod support;
#[cfg(test)]
#[path = "../dispatch_observer_harness.rs"]
mod tests;
#[cfg(test)]
#[path = "../rmcp_runtime_tests.rs"]
mod rmcp_runtime_tests;
@@ -24,6 +24,7 @@ use super::response::{
resource_templates_list_result, resources_list_result, take_confirmation_token,
tools_list_result,
};
use super::rmcp_dispatch::handle_tools_command;
use super::{AgentRoutePath, AppState};
use crate::{
auth::VerifiedMachineCredential,
@@ -38,7 +39,6 @@ use crate::{
ResourcesCommand, ResourcesListCommand, ResourcesOutcome, ServiceContext, SetLevelCommand,
ToolCallCommand, ToolsCommand, ToolsListCommand, ToolsOutcome, handle_completion_command,
handle_logging_command, handle_prompts_command, handle_resources_command,
handle_tools_command,
},
tool_error::execution_locale,
transport::{ResponseMode, session_id_from_headers, transport_response},
@@ -37,16 +37,14 @@ use futures_util::stream;
use serde_json::{Number, Value, json};
use tokio::sync::{mpsc, watch};
use super::rmcp_dispatch::handle_tools_command;
use super::{
AppState,
response::{ToolCommandPayload, tool_command_payload, tool_command_response},
};
use crate::{
jsonrpc::request_id,
protocol::{
ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand, ToolsOutcome,
handle_tools_command,
},
protocol::{ContinuationSupport, ServiceContext, ToolCallCommand, ToolsCommand, ToolsOutcome},
transport::{ResponseMode, sse_response},
};
@@ -0,0 +1,67 @@
//! Runtime SDK Tools dispatch; admission, lifecycle and response projection stay with the caller.
use std::sync::Arc;
use rmcp::model::{CallToolRequestParams, PaginatedRequestParams};
use serde_json::Value;
use super::{AppState, lifecycle::ToolCallLifecycle};
use crate::protocol::{
ServiceContext, ToolCallCommand, ToolCallOutcome, ToolsCommand, ToolsListCommand, ToolsOutcome,
};
// Crank extensions are not SDK fields and must survive the typed request boundary unchanged.
enum SdkToolsCommand {
List {
params: PaginatedRequestParams,
limit: Option<usize>,
},
Call {
params: CallToolRequestParams,
confirmation_token: Option<String>,
},
}
pub(super) async fn handle_tools_command(
state: &Arc<AppState>,
context: ServiceContext<'_>,
command: ToolsCommand,
lifecycle: Option<ToolCallLifecycle>,
) -> ToolsOutcome {
let request = match command {
ToolsCommand::List(list) => SdkToolsCommand::List {
params: PaginatedRequestParams::default().with_cursor(list.cursor),
limit: list.limit,
},
ToolsCommand::Call(call) => {
let Value::Object(arguments) = call.arguments else {
return ToolsOutcome::Call(ToolCallOutcome::InvalidParams(
"tool arguments must be an object".to_owned(),
));
};
SdkToolsCommand::Call {
params: CallToolRequestParams::new(call.tool_name).with_arguments(arguments),
confirmation_token: call.confirmation_token,
}
}
};
#[cfg(test)]
super::dispatch_observer::sdk_tools_dispatch_enter();
let command = match request {
SdkToolsCommand::List { params, limit } => ToolsCommand::List(ToolsListCommand {
cursor: params.cursor,
limit,
}),
SdkToolsCommand::Call {
params,
confirmation_token,
} => ToolsCommand::Call(ToolCallCommand {
tool_name: params.name.into_owned(),
arguments: Value::Object(params.arguments.unwrap_or_default()),
confirmation_token,
}),
};
crate::protocol::handle_tools_command(state, context, command, lifecycle).await
}
@@ -0,0 +1,356 @@
//! #107: real build_app endpoint controls plus a separate SDK structural seam oracle.
//! No SDK transport router is used. The structural oracle alone does not prove wire parity.
use std::{
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
};
use axum::{Router, routing::post};
use crank_core::{
AgentOperationBinding, AgentStatus, AgentVersion, PlatformApiKeyId, ToolSelectionPolicy,
};
use crank_registry::{
CreateAgentDraftVersionRequest, PostgresRegistry, PublishAgentRequest, PublishRequest,
};
use crank_runtime::{
InMemoryCoordinationStateStore, RequestRateLimitConfig, RequestRateLimiter, SecretCrypto,
};
use serde_json::{Value, json};
use super::{CounterSet, observe, sdk_tools_dispatch_enter, support::*};
struct Server(tokio::task::JoinHandle<()>, String);
impl Drop for Server {
fn drop(&mut self) {
self.0.abort();
}
}
async fn serve(app: Router) -> Server {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
Server(
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
}),
format!("http://{address}"),
)
}
struct Endpoint {
server: Server,
_upstream: Server,
registry: PostgresRegistry,
key: String,
counters: Arc<CounterSet>,
calls: Arc<AtomicUsize>,
}
impl Endpoint {
async fn started() -> Self {
// First caller owns the process-wide fixture and its atexit cleanup, including RED panics.
let _ =
crank_test_support::postgres_schema_url_for_task("rmcp_runtime_owner", "t_aaaea124")
.await;
let registry = test_registry().await;
let calls = Arc::new(AtomicUsize::new(0));
let upstream = serve(
Router::new()
.route("/crm/leads", post(create_lead))
.with_state(calls.clone()),
)
.await;
let operation = test_operation(&upstream.1);
registry
.create_operation(&workspace_id(), &operation, Some("alice"))
.await
.unwrap();
registry
.publish_operation(PublishRequest {
workspace_id: &workspace_id(),
operation_id: &operation.id,
version: 1,
published_at: &test_time(),
published_by: Some("alice"),
})
.await
.unwrap();
publish_agent(&registry, &operation).await;
let key = create_api_key(&registry).await;
let counters = Arc::new(CounterSet::default());
let app = crate::build_app(
registry.clone(),
Duration::ZERO,
Some("https://crank.example.com".into()),
SecretCrypto::new("test-master-key-00000000000000000000000000000000").unwrap(),
crank_runtime::community_with_outbound_policy(
crank_runtime::OutboundHttpPolicy::allowing_hosts(["127.0.0.1"]),
)
.build(),
RequestRateLimiter::new(RequestRateLimitConfig::new(10_000, 10_000).unwrap()),
Arc::new(InMemoryCoordinationStateStore::default()),
Arc::new(crate::session::InMemorySessionStore::default()),
Arc::new(crate::auth::CommunityMachineCredentialVerifier),
);
let server = serve(observe_requests(app, counters.clone(), None)).await;
Self {
server,
_upstream: upstream,
registry,
key,
counters,
calls,
}
}
async fn post(&self, revision: &str, session: Option<&str>, body: &Value) -> reqwest::Response {
let mut request = reqwest::Client::new()
.post(format!(
"{}/v1/{WORKSPACE_SLUG}/{AGENT_SLUG}",
self.server.1
))
.bearer_auth(&self.key)
// Also guards the legacy JSON-only contract; no SSE parsing fallback here.
.header("Accept", "application/json")
.header("MCP-Protocol-Version", revision);
if let Some(session) = session {
request = request.header("MCP-Session-Id", session);
}
if revision == MODERN_REVISION {
request = request.header("Mcp-Method", body["method"].as_str().unwrap());
if let Some(name) = body["params"]["name"].as_str() {
request = request.header("Mcp-Name", name);
}
}
request.json(body).send().await.unwrap()
}
async fn session(&self, revision: &str) -> Option<String> {
if revision == MODERN_REVISION {
return None;
}
let response = self.post(revision, None, &legacy_initialize(1)).await;
assert_eq!(response.status(), 200);
let session = response.headers()["MCP-Session-Id"]
.to_str()
.unwrap()
.to_owned();
let body = json_body(response).await;
assert_eq!(body["result"]["protocolVersion"], revision);
assert!(body["result"]["capabilities"]["tools"].is_object());
let response = self
.post(revision, Some(&session), &initialized_notification())
.await;
assert_eq!(response.status(), 202);
Some(session)
}
async fn list(&self, revision: &str, session: Option<&str>, expected_name: &str) -> usize {
let before = self.counters.sdk_tools_dispatch();
let mut body = json!({"jsonrpc":"2.0", "id":10, "method":"tools/list", "params":{}});
if revision == MODERN_REVISION {
body["params"]["_meta"] = modern_meta();
}
let calls = self.calls.load(Ordering::SeqCst);
let response = self.post(revision, session, &body).await;
assert_eq!(response.status(), 200);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("application/json")
);
let body = json_body(response).await;
assert_eq!(body["id"], 10);
assert_eq!(body["result"]["tools"].as_array().unwrap().len(), 1);
assert_eq!(body["result"]["tools"][0]["name"], expected_name);
assert!(body["error"].is_null(), "{body}");
assert_eq!(
self.calls.load(Ordering::SeqCst),
calls,
"listing must not execute upstream"
);
self.counters.sdk_tools_dispatch() - before
}
async fn call(&self, revision: &str, session: Option<&str>, name: &str, email: &str) -> usize {
let before = self.counters.sdk_tools_dispatch();
let arrivals = self.calls.load(Ordering::SeqCst);
let mut body = if revision == MODERN_REVISION {
modern_tool_call(11, email)
} else {
legacy_tool_call(11, email)
};
body["params"]["name"] = json!(name);
let response = self.post(revision, session, &body).await;
assert_eq!(response.status(), 200);
assert!(
response.headers()["content-type"]
.to_str()
.unwrap()
.starts_with("application/json")
);
let body = json_body(response).await;
assert_eq!(body["id"], 11);
assert!(body["error"].is_null(), "{body}");
assert_ne!(body["result"]["isError"], true, "{body}");
assert_scoped_output(revision, &body, email);
if revision == MODERN_REVISION {
assert_eq!(body["result"]["resultType"], "complete");
}
assert_eq!(self.calls.load(Ordering::SeqCst) - arrivals, 1);
self.counters.sdk_tools_dispatch() - before
}
async fn publish_renamed_tool(&self) {
let now = time::OffsetDateTime::now_utc();
let version = AgentVersion {
agent_id: agent_id(),
version: 2,
status: AgentStatus::Draft,
instructions: json!({}),
tool_selection_policy: ToolSelectionPolicy::default(),
created_at: now,
};
let bindings = [AgentOperationBinding {
operation_id: crank_core::OperationId::new("op_create_lead"),
operation_version: 1,
tool_name: "new_publication_tool".into(),
tool_title: "New Tool".into(),
tool_description_override: None,
enabled: true,
}];
self.registry
.create_agent_draft_version(CreateAgentDraftVersionRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: &version,
bindings: &bindings,
updated_at: &now,
})
.await
.unwrap();
self.registry
.publish_agent(PublishAgentRequest {
workspace_id: &workspace_id(),
agent_id: &agent_id(),
version: 2,
published_at: &now,
published_by: Some("alice"),
expected_state: None,
})
.await
.unwrap();
}
}
async fn endpoint_control(revision: &str) -> [usize; 2] {
let h = Endpoint::started().await;
let session = h.session(revision).await;
let session = session.as_deref();
let list_dispatches = h.list(revision, session, TOOL_NAME).await;
let call_dispatches = h
.call(
revision,
session,
TOOL_NAME,
&format!("{revision}@example.test"),
)
.await;
// A fresh publication must be visible without reinitialize or a new endpoint.
h.publish_renamed_tool().await;
h.list(revision, session, "new_publication_tool").await;
h.call(
revision,
session,
"new_publication_tool",
"new-publication@example.test",
)
.await;
h.registry
.revoke_platform_api_key(
&workspace_id(),
&PlatformApiKeyId::new("pk_dispatch_observer"),
&time::OffsetDateTime::now_utc(),
)
.await
.unwrap();
let before_sdk = h.counters.sdk_tools_dispatch();
let arrivals = h.calls.load(Ordering::SeqCst);
let mut denied = if revision == MODERN_REVISION {
modern_tool_call(12, "denied@example.test")
} else {
legacy_tool_call(12, "denied@example.test")
};
denied["params"]["name"] = json!("new_publication_tool");
assert_eq!(h.post(revision, session, &denied).await.status(), 401);
assert_eq!(
h.calls.load(Ordering::SeqCst),
arrivals,
"revoked credential must not execute upstream"
);
assert_eq!(
h.counters.sdk_tools_dispatch(),
before_sdk,
"revocation must reject before SDK dispatch"
);
eprintln!(
"existing GREEN {revision}: JSON list/call, scoped output, upstream=2, publication refresh, revoked=401/no outbound; SDK list/call deltas={:?}",
[list_dispatches, call_dispatches]
);
[list_dispatches, call_dispatches]
}
#[tokio::test]
async fn rmcp_runtime_existing_wire_modern() {
endpoint_control(MODERN_REVISION).await;
}
#[tokio::test]
async fn rmcp_runtime_existing_wire_legacy() {
endpoint_control(LEGACY_REVISION).await;
}
#[tokio::test]
async fn rmcp_runtime_sdk_dispatch_modern() {
let counts = endpoint_control(MODERN_REVISION).await;
assert_eq!(
counts,
[1, 1],
"real endpoint tools/list and tools/call must each enter SDK typed dispatch once (structural seam oracle)"
);
}
#[tokio::test]
async fn rmcp_runtime_sdk_dispatch_legacy() {
let counts = endpoint_control(LEGACY_REVISION).await;
assert_eq!(
counts,
[1, 1],
"real endpoint tools/list and tools/call must each enter SDK typed dispatch once (structural seam oracle)"
);
}
#[tokio::test]
async fn rmcp_runtime_observer_is_request_scoped() {
let counters = Arc::new(CounterSet::default());
sdk_tools_dispatch_enter();
assert_eq!(counters.sdk_tools_dispatch(), 0);
observe(counters.clone(), async {
sdk_tools_dispatch_enter();
})
.await;
assert_eq!(counters.sdk_tools_dispatch(), 1);
let other = Arc::new(CounterSet::default());
observe(other.clone(), async {
sdk_tools_dispatch_enter();
})
.await;
assert_eq!(other.sdk_tools_dispatch(), 1);
assert_eq!(counters.sdk_tools_dispatch(), 1);
}
+3 -1
View File
@@ -1,6 +1,6 @@
# Переход Crank на официальный MCP SDK rmcp
Статус: планирование одобрено владельцем 27.10.2026; 05.11.2026 отдельно разрешён только изолированный опыт этапа 1 (#106). Этапы 2/3 (#107/#108), новая реализация 4.7 и production-переключение этим разрешением не запускаются. Исполняемый кандидат и конкретные несовместимости: [rmcp106-tools-adapter.md](rmcp106-tools-adapter.md); это не завершённая миграция. Владелец очереди — hermes_tl; реализация — hermes_dev; независимая проверка — hermes_qa; Git/CI/релизы — hermes_devops. ARC подключается к конкретному техническому затруднению, не как обязательный новый этап. Business reconciliation 4.6 отменена решением владельца и [issue #34](https://git.itexp.me/bsodfather/crank/issues/34); она не prerequisite SDK. Input/unknown safety и остальные защитные ограничения сохраняются.
Статус: планирование одобрено владельцем 27.10.2026; 05.11.2026 разрешён изолированный опыт этапа 1 (#106), поставленный в v0.4.0-rc.15. [Решением владельца 08.11.2026](https://git.itexp.me/bsodfather/crank/issues/107#issuecomment-2463) разрешён первый Tools-срез этапа 2 (#107) в действующем endpoint без смены transport. #108, новая реализация 4.7 и production-переключение этим разрешением не запускаются. Исполняемый кандидат и конкретные несовместимости: [rmcp106-tools-adapter.md](rmcp106-tools-adapter.md); это не завершённая миграция. Владелец очереди — hermes_tl; реализация — hermes_dev; независимая проверка — hermes_qa; Git/CI/релизы — hermes_devops. ARC подключается к конкретному техническому затруднению, не как обязательный новый этап. Business reconciliation 4.6 отменена решением владельца и [issue #34](https://git.itexp.me/bsodfather/crank/issues/34); она не prerequisite SDK. Input/unknown safety и остальные защитные ограничения сохраняются.
## Результат
@@ -31,6 +31,8 @@
Подключить SDK к действующему пути и перенести стандартные envelopes, dispatch, lifecycle и transport. Порядок переноса устанавливается по результату первого опыта, без параллельных writers одних MCP-файлов.
Первый срез #107: `build_app` направляет `tools/list` обеих revisions и `tools/call` через `app/rmcp_dispatch.rs`. Параметры rmcp=3.7.0 (`PaginatedRequestParams`/`CallToolRequestParams`) определяют команду существующего shared Tools service; расширения Crank `limit`/confirmation сохраняются отдельно. Потребитель — штатный MCP HTTP клиент, не изолированный router #106. Текущие admission, свежая identity, lifecycle, era-specific ответы и PostgreSQL sessions остаются у прежнего transport; SDK HTTP transport не подключён. Это только Tools request dispatch/model seam: SDK response envelopes, остальные handlers, transport и lifecycle ещё не перенесены. Полный #107 не завершён; проверки #106 не являются доказательством завершения миграции.
Проверяемый результат:
- Через SDK проходят действующие Tools, Resources, Prompts, completion, уведомления и подписки в применимых revisions, а также progress/cancel и существующая logging policy.
+84
View File
@@ -0,0 +1,84 @@
#!/usr/bin/env python3
"""Fail-closed detector for release-tooling-only CI changes."""
from __future__ import annotations
import os
import re
import subprocess
import sys
from pathlib import Path
_SHA = re.compile(r"[0-9a-fA-F]{40}\Z")
_ALLOWED = {
".gitea/workflows/release.yml",
"scripts/scan-images.sh",
"scripts/check-image-scan.py",
"scripts/ci-release-assets.py",
"scripts/ci-release-resume.py",
"tests/unit/test_scan_images.py",
"tests/unit/test_check_image_scan.py",
"tests/unit/test_ci_release_assets.py",
"tests/unit/test_ci_release_resume.py",
}
_ALLOWED_BYTES = {path.encode("utf-8") for path in _ALLOWED}
def _git(repo: Path, *args: str) -> subprocess.CompletedProcess[bytes] | None:
try:
return subprocess.run(
["git", "-C", str(repo), *args],
check=False,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
)
except OSError:
return None
def release_tooling_only(
repo: Path, event_name: str, before_sha: str, pr_base_sha: str, force_full: str
) -> bool:
if force_full.lower() != "false" or event_name not in {"push", "pull_request"}:
return False
raw_base = before_sha if event_name == "push" else pr_base_sha
if not _SHA.fullmatch(raw_base):
return False
available = _git(repo, "cat-file", "-e", f"{raw_base}^{{commit}}")
if available is None or available.returncode != 0:
return False
if event_name == "pull_request":
merge_base = _git(repo, "merge-base", "HEAD", raw_base)
if merge_base is None or merge_base.returncode != 0:
return False
raw_base = merge_base.stdout.decode("ascii", errors="ignore").strip()
if not _SHA.fullmatch(raw_base):
return False
diff = _git(repo, "diff", "--no-renames", "--name-only", "-z", raw_base, "HEAD")
if diff is None or diff.returncode != 0:
return False
paths = diff.stdout.split(b"\0")
paths = [path for path in paths if path]
return bool(paths) and all(path in _ALLOWED_BYTES for path in paths)
def main() -> int:
env = os.environ
ci_only = release_tooling_only(
Path.cwd(),
env.get("GITEA_EVENT_NAME", ""),
env.get("GITEA_EVENT_BEFORE", ""),
env.get("GITEA_PR_BASE_SHA", ""),
env.get("FORCE_FULL", ""),
)
output = env.get("GITHUB_OUTPUT")
if not output:
print("Release-tooling CI scope unavailable; using full Rust checks.")
return 0
with open(output, "a", encoding="utf-8") as stream:
stream.write(f"ci_only={'true' if ci_only else 'false'}\n")
print("Release-tooling-only change detected." if ci_only else "Full Rust checks required.")
return 0
if __name__ == "__main__":
raise SystemExit(main())
+35 -7
View File
@@ -1,8 +1,8 @@
#!/bin/sh
# Scan the built Crank server images with a pinned Trivy and fail closed.
#
# The wrapper downloads and checksum-verifies one fixed Trivy release, downloads
# one fresh vulnerability database, then scans every requested image by its
# The wrapper loads or downloads and checksum-verifies one fixed Trivy release,
# downloads one fresh vulnerability database, then scans every requested image by its
# immutable Docker id with a fully pinned policy. It never trusts a local
# trivy.yaml, .trivyignore, VEX file or skip list: --config and --ignorefile
# point at /dev/null and every inherited TRIVY_* variable is removed before
@@ -14,6 +14,7 @@
#
# db/metadata.json copy of the actual downloaded Trivy DB metadata
# db-download.log database download log
# scanner-cache-source.log archive source provenance
# scanner.json pinned scanner version and scan policy receipt
# <NN-slug>.json raw Trivy JSON report per image
# <NN-slug>.scan.log Trivy scan log per image
@@ -45,6 +46,10 @@ trivy_version="0.70.0"
archive="trivy_${trivy_version}_Linux-64bit.tar.gz"
expected_sha256="8b4376d5d6befe5c24d503f10ff136d9e0c49f9127a4279fd110b727929a5aa9"
download_url="https://github.com/aquasecurity/trivy/releases/download/v${trivy_version}/${archive}"
# Fixed GitHub asset ID for the Trivy 0.70.0 Linux 64-bit release archive.
asset_api_url="https://api.github.com/repos/aquasecurity/trivy/releases/assets/398381981"
tool_cache_root="${RUNNER_TOOL_CACHE:-/opt/hostedtoolcache}"
cached_archive="$tool_cache_root/trivy/$trivy_version/$archive"
db_repository_primary="ghcr.io/aquasecurity/trivy-db:2"
db_repository_fallback="mirror.gcr.io/aquasec/trivy-db:2"
@@ -102,11 +107,34 @@ PY
exit 2
}
# Download and checksum-verify the pinned scanner exactly once.
if ! curl --fail --silent --show-error --location --max-time 300 \
"$download_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-download.log" 2>&1; then
fail_all "could not download pinned Trivy ${trivy_version}"
# Load the exact-version archive from the runner cache when preinstalled;
# otherwise use the bounded network routes. The shared cache is read-only here.
cache_source_log="$output_dir/scanner-cache-source.log"
: > "$cache_source_log"
if [ -f "$cached_archive" ]; then
printf 'archive_source=runner-tool-cache\n' > "$cache_source_log"
if ! cp "$cached_archive" "$temp_dir/$archive"; then
fail_all "could not copy the pinned Trivy archive from runner tool cache"
fi
else
printf 'archive_source=network\n' > "$cache_source_log"
if ! curl --fail --silent --show-error --location --max-time 300 \
"$download_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-download.log" 2>&1; then
rm -f "$temp_dir/$archive"
if ! curl --fail --silent --show-error --location --max-time 300 \
--header 'Accept: application/octet-stream' \
"$asset_api_url" --output "$temp_dir/$archive" \
>"$output_dir/scanner-api-download.log" 2>&1; then
printf 'network_download=failed\n' >> "$cache_source_log"
fail_all "could not download pinned Trivy ${trivy_version} from release URL or GitHub asset API"
fi
printf 'archive_source=github-release-asset-api\n' > "$cache_source_log"
printf 'Downloaded pinned Trivy %s from GitHub release asset API.\n' "$trivy_version" \
>>"$output_dir/scanner-api-download.log"
else
printf 'archive_source=github-release-download\n' > "$cache_source_log"
fi
fi
if ! printf '%s %s\n' "$expected_sha256" "$temp_dir/$archive" \
| sha256sum --check --status; then
+140
View File
@@ -0,0 +1,140 @@
from __future__ import annotations
import subprocess
import tempfile
import unittest
import importlib.util
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
SCRIPT = ROOT / "scripts" / "ci-release-tooling-scope.py"
spec = importlib.util.spec_from_file_location("ci_release_tooling_scope", SCRIPT)
assert spec and spec.loader
scope = importlib.util.module_from_spec(spec)
spec.loader.exec_module(scope)
WORKFLOW = ROOT / ".gitea/workflows/ci.yml"
_FALSE = "false"
class ReleaseToolingScopeTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.repo = Path(self.temp.name)
self.git("init", "-q")
self.git("config", "user.email", "ci-scope@example.test")
self.git("config", "user.name", "CI Scope Test")
self.write("src/lib.rs", "pub fn initial() {}\n")
self.write("scripts/scan-images.sh", "#!/bin/sh\nexit 0\n")
self.write("tests/unit/test_scan_images.py", "# initial\n")
self.git("add", ".")
self.git("commit", "-qm", "baseline")
self.base = self.head()
def git(self, *args: str) -> str:
result = subprocess.run(
["git", "-C", str(self.repo), *args],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
return result.stdout.strip()
def head(self) -> str:
return self.git("rev-parse", "HEAD")
def write(self, relative: str, content: str) -> None:
path = self.repo / relative
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(content, encoding="utf-8")
def commit(self, message: str = "change") -> None:
self.git("add", "-A")
self.git("commit", "-qm", message)
def classify(self, event="push", before=None, base=None, force=_FALSE) -> bool:
return scope.release_tooling_only(
self.repo,
event,
self.base if before is None else before,
self.base if base is None else base,
force,
)
def test_release_only_diff_is_safe_for_push_and_pull_request(self):
self.write(".gitea/workflows/release.yml", "# release tooling update\n")
self.write("scripts/scan-images.sh", "#!/bin/sh\n# scanner update\n")
self.commit()
self.assertTrue(self.classify("push", before=self.base))
self.assertTrue(self.classify("pull_request", base=self.base))
def test_rust_or_mixed_diff_requires_full_ci(self):
self.write("src/lib.rs", "pub fn changed() {}\n")
self.commit("Rust change")
self.assertFalse(self.classify("push", before=self.base))
self.write("scripts/scan-images.sh", "#!/bin/sh\n# tooling change\n")
self.write("src/lib.rs", "pub fn changed_again() {}\n")
self.commit("mixed change")
self.assertFalse(self.classify("push", before=self.base))
def test_rename_from_rust_into_allowlist_is_not_safe(self):
(self.repo / ".gitea/workflows").mkdir(parents=True)
self.git("mv", "src/lib.rs", ".gitea/workflows/release.yml")
self.commit("rename Rust source into release path")
self.assertFalse(self.classify("push", before=self.base))
def test_unavailable_zero_empty_and_missing_bases_require_full_ci(self):
self.write("scripts/scan-images.sh", "#!/bin/sh\n# allowed\n")
self.commit()
self.assertFalse(self.classify("push", before=""))
self.assertFalse(self.classify("push", before="0" * 40))
self.assertFalse(self.classify("push", before="1" * 40))
self.assertFalse(self.classify("push", before=self.head()))
self.assertFalse(self.classify("pull_request", base=""))
def test_manual_feature_and_unknown_force_metadata_require_full_ci(self):
self.write("scripts/scan-images.sh", "#!/bin/sh\n# allowed\n")
self.commit()
self.assertFalse(self.classify("workflow_dispatch", before=self.base))
self.assertFalse(self.classify("push", before=self.base, force="true"))
self.assertFalse(self.classify("push", before=self.base, force=""))
def test_non_allowlisted_ci_self_change_requires_full_ci(self):
self.write(".gitea/workflows/ci.yml", "# detector workflow change\n")
self.commit()
self.assertFalse(self.classify("push", before=self.base))
class WorkflowScopeTests(unittest.TestCase):
def test_only_four_heavy_rust_steps_are_skippable(self):
workflow = WORKFLOW.read_text(encoding="utf-8")
self.assertIn("run: python3 scripts/ci-release-tooling-scope.py", workflow)
self.assertIn("FORCE_FULL: ${{ inputs.validation_level == 'feature' || contains(gitea.event.pull_request.labels.*.name, 'feature-ready') }}", workflow)
conditional = "if: steps.release_tooling.outputs.ci_only != 'true'"
for name in (
"Check typed runtime configuration contract",
"Check canonical migration contract",
"Check typed metrics contract",
"Run Crank story ATDD",
):
start = workflow.index(f"- name: {name}")
self.assertIn(conditional, workflow[start : start + 180])
for name in (
"Install Rust toolchain",
"Run tooling unit tests",
"Check formatting",
"Check Rust boundaries",
"Check OpenAPI matrix and corpus compatibility versions",
):
start = workflow.index(f"- name: {name}")
self.assertNotIn("if:", workflow[start : start + 160])
self.assertIn("name: Rust Checks", workflow)
self.assertIn("name: UI Checks", workflow)
self.assertIn("name: Required Checks", workflow)
if __name__ == "__main__":
unittest.main()
+94 -4
View File
@@ -27,9 +27,18 @@ import os
import sys
args = sys.argv[1:]
if os.environ.get("FAKE_CURL_FAIL") == "1":
sys.stderr.write("curl: (7) failed to connect\\n")
url = next((value for value in args if value.startswith("https://")), "")
api_download = url == "https://api.github.com/repos/aquasecurity/trivy/releases/assets/398381981"
failed = os.environ.get("FAKE_CURL_FAIL") == "1"
failed = failed or (not api_download and os.environ.get("FAKE_CURL_DIRECT_FAIL") == "1")
failed = failed or (api_download and os.environ.get("FAKE_CURL_API_FAIL") == "1")
if failed:
sys.stderr.write("curl: (22) fixture download failure for " + url + "\\n")
sys.exit(7)
if api_download:
if "--header" not in args or args[args.index("--header") + 1] != "Accept: application/octet-stream":
sys.stderr.write("curl: missing octet-stream Accept header\\n")
sys.exit(2)
output = None
for index, value in enumerate(args):
if value in ("--output", "-o"):
@@ -37,7 +46,8 @@ for index, value in enumerate(args):
if output is None:
sys.stderr.write("curl: missing --output\\n")
sys.exit(2)
with open(os.environ["FAKE_CURL_ARCHIVE"], "rb") as source:
archive_path = os.environ.get("FAKE_CURL_API_ARCHIVE", os.environ["FAKE_CURL_ARCHIVE"]) if api_download else os.environ["FAKE_CURL_ARCHIVE"]
with open(archive_path, "rb") as source:
payload = source.read()
with open(output, "wb") as target:
target.write(payload)
@@ -176,6 +186,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
images=(VULN_TAG, CLEAN_TAG),
trivy_fail_id=None,
curl_fail=False,
curl_direct_fail=False,
curl_api_fail=False,
api_checksum_mismatch=False,
cache_archive=None,
extra_env=None,
workdir_files=None,
run_in_workdir=False,
@@ -214,6 +228,13 @@ class ScanImagesWrapperTests(unittest.TestCase):
archive_path = root / "trivy-fixture.tar.gz"
archive_path.write_bytes(fixture_archive)
api_archive_path = root / "trivy-api-fixture.tar.gz"
api_archive_path.write_bytes(fixture_archive + b"tampered" if api_checksum_mismatch else fixture_archive)
tool_cache = root / "runner-tool-cache"
if cache_archive is not None:
cached_path = tool_cache / "trivy" / "0.70.0" / "trivy_0.70.0_Linux-64bit.tar.gz"
cached_path.parent.mkdir(parents=True)
cached_path.write_bytes(fixture_archive if cache_archive == "valid" else b"invalid archive")
reports = root / "reports"
reports.mkdir()
@@ -246,8 +267,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
env.update(
{
"PATH": f"{bin_dir}:{env['PATH']}",
"RUNNER_TOOL_CACHE": str(tool_cache),
"CRANK_IMAGE_SCAN_OUTPUT_DIR": str(evidence),
"FAKE_CURL_ARCHIVE": str(archive_path),
"FAKE_CURL_API_ARCHIVE": str(api_archive_path),
"FAKE_IMAGE_MAP": str(image_map),
"FAKE_REPORT_DIR": str(reports),
"FAKE_DOCKER_LOG": str(docker_log),
@@ -258,6 +281,10 @@ class ScanImagesWrapperTests(unittest.TestCase):
env["FAKE_TRIVY_FAIL_ID"] = trivy_fail_id
if curl_fail:
env["FAKE_CURL_FAIL"] = "1"
if curl_direct_fail:
env["FAKE_CURL_DIRECT_FAIL"] = "1"
if curl_api_fail:
env["FAKE_CURL_API_FAIL"] = "1"
if extra_env:
env.update(extra_env)
@@ -442,6 +469,68 @@ class ScanImagesWrapperTests(unittest.TestCase):
self.assertEqual(docker_calls, [])
self.assertEqual(trivy_calls, [])
def test_pinned_asset_api_fallback_downloads_and_verifies_same_archive(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True
)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(receipt["overall"]["status"], "pass")
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("GitHub release asset API", (evidence / "scanner-api-download.log").read_text())
self.assertTrue(any("--download-db-only" in call["args"] for call in trivy_calls))
scanner = json.loads((evidence / "scanner.json").read_text(encoding="utf-8"))
self.assertEqual(scanner["expected_version"], "0.70.0")
def test_pinned_asset_api_fallback_failure_fails_closed_with_both_logs(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True, curl_api_fail=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-api-download.log").read_text())
self.assertEqual(trivy_calls, [])
def test_pinned_asset_api_fallback_checksum_mismatch_never_executes_trivy(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), curl_direct_fail=True, api_checksum_mismatch=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("checksum mismatch", result.stderr)
self.assertEqual(trivy_calls, [])
def test_preloaded_pinned_archive_runs_without_network(self):
result, root, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), cache_archive="valid", curl_fail=True
)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertEqual(receipt["overall"]["status"], "pass")
self.assertEqual(
(evidence / "scanner-cache-source.log").read_text(),
"archive_source=runner-tool-cache\n",
)
self.assertFalse((evidence / "scanner-download.log").exists())
self.assertFalse((evidence / "scanner-api-download.log").exists())
cached = root / "runner-tool-cache" / "trivy" / "0.70.0" / "trivy_0.70.0_Linux-64bit.tar.gz"
self.assertEqual(cached.read_bytes(), (root / "trivy-fixture.tar.gz").read_bytes())
self.assertTrue(any("--download-db-only" in call["args"] for call in trivy_calls))
def test_preloaded_archive_hash_mismatch_fails_before_network_or_execution(self):
result, _, evidence, receipt, _, trivy_calls = self.run_scan(
images=(CLEAN_TAG,), cache_archive="bad", curl_fail=True
)
self.assertEqual(result.returncode, 2)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("checksum mismatch", result.stderr)
self.assertEqual(
(evidence / "scanner-cache-source.log").read_text(),
"archive_source=runner-tool-cache\n",
)
self.assertFalse((evidence / "scanner-download.log").exists())
self.assertFalse((evidence / "scanner-api-download.log").exists())
self.assertEqual(trivy_calls, [])
def test_unknown_image_is_error_and_is_never_scanned(self):
missing = "crank/missing:ci"
result, _, _, receipt, _, trivy_calls = self.run_scan(images=(missing, CLEAN_TAG))
@@ -457,7 +546,8 @@ class ScanImagesWrapperTests(unittest.TestCase):
result, _, evidence, receipt, _, _ = self.run_scan(curl_fail=True)
self.assertEqual(result.returncode, 2, result.stderr)
self.assertEqual(receipt["overall"]["status"], "error")
self.assertIn("failed to connect", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-download.log").read_text())
self.assertIn("fixture download failure", (evidence / "scanner-api-download.log").read_text())
def test_evidence_kept_even_when_gate_is_red(self):
_, _, evidence, receipt, _, _ = self.run_scan()