#![cfg(feature = "server")]
use std::net::SocketAddr;
use std::sync::Arc;
use parking_lot::Mutex;
use symforge::domain::ProjectStateDir;
use symforge::live_index::LiveIndex;
use symforge::protocol::SymForgeServer;
use symforge::server::{
ApiKeyStore, AuthConfig, AuthLayerState, ServerRuntime, apply_bearer_auth,
mcp_http::build_mcp_router,
};
use symforge::sidecar::governor::RequestGovernor;
use symforge::watcher::WatcherInfo;
fn project_state(root: &std::path::Path) -> ProjectStateDir {
ProjectStateDir::new(root.join(symforge::paths::SYMFORGE_DIR_NAME))
}
#[test]
fn mint_persists_hash_only_raw_shown_once() {
let tmp = tempfile::tempdir().expect("tempdir");
let project_state = project_state(tmp.path());
let store = ApiKeyStore::open(&project_state);
let minted = store.mint("ci").expect("mint");
let raw = minted.raw_secret.clone();
assert!(raw.starts_with("sf_"));
let db_path = project_state.as_path().join("api-keys.db");
let bytes = std::fs::read(&db_path).expect("read db");
let needle = raw.as_bytes();
let contains = bytes.windows(needle.len()).any(|w| w == needle);
assert!(
!contains,
"raw secret must never be persisted (hash-only store)"
);
let listed = store.list().expect("list");
assert_eq!(listed.len(), 1);
let json = serde_json::to_string(&listed).expect("serialize");
assert!(
!json.contains(&raw),
"list output must not contain raw secret"
);
assert!(json.contains("fingerprint"));
}
#[test]
fn list_never_returns_raw_after_reopen() {
let tmp = tempfile::tempdir().expect("tempdir");
let project_state = project_state(tmp.path());
let raw = {
let store = ApiKeyStore::open(&project_state);
store.mint("k").expect("mint").raw_secret
};
let store2 = ApiKeyStore::open(&project_state);
assert!(store2.verify(&raw));
let json = serde_json::to_string(&store2.list().expect("list")).expect("serialize");
assert!(!json.contains(&raw));
}
fn runtime_with_store(store: Arc<ApiKeyStore>) -> ServerRuntime {
let index = LiveIndex::empty();
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
let protocol = Arc::new(SymForgeServer::new(
Arc::clone(&index),
"keys-it".to_string(),
watcher_info,
None,
None,
));
let governor = Arc::new(RequestGovernor::new());
ServerRuntime::build_runtime(
index,
protocol,
governor,
AuthConfig::new(Some("bootstrap-key".to_string())),
None,
)
.with_key_store(store)
}
struct TestServer {
addr: SocketAddr,
shutdown: Option<tokio::sync::oneshot::Sender<()>>,
join: tokio::task::JoinHandle<()>,
}
impl TestServer {
fn mcp_url(&self) -> String {
format!("http://{}/mcp", self.addr)
}
async fn shutdown(mut self) {
if let Some(tx) = self.shutdown.take() {
let _ = tx.send(());
}
let _ = self.join.await;
}
}
async fn start_mcp(runtime: ServerRuntime) -> TestServer {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind");
let addr = listener.local_addr().expect("local_addr");
let router = build_mcp_router(&runtime, addr);
let mut auth_state = AuthLayerState::new(runtime.auth().clone(), true);
if let Some(store) = runtime.key_store() {
auth_state = auth_state.with_key_store(Arc::clone(store));
}
let app = apply_bearer_auth(router, auth_state);
let (tx, rx) = tokio::sync::oneshot::channel::<()>();
let join = tokio::spawn(async move {
let shutdown = async {
let _ = rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
TestServer {
addr,
shutdown: Some(tx),
join,
}
}
async fn mcp_status(
url: &str,
bearer: &str,
body: Option<serde_json::Value>,
) -> reqwest::StatusCode {
let client = reqwest::Client::new();
let request = client
.post(url)
.header("Content-Type", "application/json")
.header("Accept", "application/json, text/event-stream")
.header("Authorization", format!("Bearer {bearer}"));
let request = if let Some(body) = body {
request.json(&body)
} else {
request.body(String::new())
};
request.send().await.expect("request sent").status()
}
#[tokio::test]
async fn minted_key_authenticates_at_mcp_revoked_rejected() {
let store = Arc::new(ApiKeyStore::open_in_memory().expect("store"));
let minted = store.mint("agent").expect("mint");
let raw = minted.raw_secret.clone();
let runtime = runtime_with_store(Arc::clone(&store));
let server = start_mcp(runtime).await;
let initialize = serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2025-06-18",
"capabilities": {},
"clientInfo": {"name": "symforge-api-key-test", "version": "1.0"}
}
});
let status = mcp_status(&server.mcp_url(), &raw, Some(initialize.clone())).await;
assert_ne!(
status,
reqwest::StatusCode::UNAUTHORIZED,
"minted key must authenticate at /mcp"
);
assert!(status.is_success());
let status = mcp_status(&server.mcp_url(), "bootstrap-key", Some(initialize)).await;
assert_ne!(status, reqwest::StatusCode::UNAUTHORIZED);
let status = mcp_status(&server.mcp_url(), "sf_not_a_key", None).await;
assert_eq!(status, reqwest::StatusCode::UNAUTHORIZED);
store.revoke(minted.record.id).expect("revoke");
let status = mcp_status(&server.mcp_url(), &raw, None).await;
assert_eq!(
status,
reqwest::StatusCode::UNAUTHORIZED,
"revoked key must be rejected at /mcp (SC-003)"
);
server.shutdown().await;
}