use std::fs::{OpenOptions, remove_file};
use std::io::{self, Write};
use std::os::unix::ffi::OsStrExt;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::thread::{self, JoinHandle};
use std::time::{SystemTime, UNIX_EPOCH};
use endpoint_libs::libs::ws::mcp_wire::{INVALID_REQUEST, JsonRpcError};
use endpoint_libs::libs::ws::transport::TransportStream;
use crate::latest::{Flag, Latest, Once};
use endpoint_libs::libs::ws::transport::framed::framed_json_neutral;
use endpoint_libs::libs::ws::transport::nagoya::NagoyaStream;
use endpoint_libs::libs::ws::{MessageStream, StreamError, WireMessage};
use nagoya::reactor::socket::TcpListener as BoundListener;
use nagoya::reactor::{Addr, Reactor, TcpListener, TcpStream, block_on_with};
use crate::{
AgentControlRequest, DebugDescriptor, DebugEvent, DebugResponse, DebugStream,
DiagnosticsRequest, IncomingRequest, decode_incoming_value, decode_wire_value,
encode_diagnostics_event, encode_initialize_response, encode_response, encode_rpc_error,
encode_tools_list_response, peek_value_request_id,
};
pub enum ControlBridgeRequest {
Agent(AgentControlRequest),
Diagnostics(DiagnosticsRequest),
}
#[derive(Debug, Clone)]
pub struct Host {
pub name: String,
pub version: String,
pub diagnostics: bool,
}
pub type ControlBridge =
Arc<dyn Fn(ControlBridgeRequest) -> Arc<Once<DebugResponse>> + Send + Sync + 'static>;
#[cfg(test)]
pub(crate) static CONTROL_TEST_LOCK: nagoya::sync::RwLock<()> = nagoya::sync::RwLock::new(());
pub struct AgentControlServer {
descriptor_path: PathBuf,
socket_path: PathBuf,
shutdown: Option<Arc<Flag>>,
thread: Option<JoinHandle<()>>,
#[cfg(feature = "capture")]
_sampling: Option<blitz_shell::DeepProfilingSession>,
}
impl AgentControlServer {
pub fn start(bridge: ControlBridge, host: Host) -> io::Result<Self> {
Self::start_inner(bridge, host, None)
}
pub fn start_with_events(
bridge: ControlBridge,
host: Host,
events: Arc<Latest<DebugEvent>>,
) -> io::Result<Self> {
Self::start_inner(bridge, host, Some(events))
}
fn start_inner(
bridge: ControlBridge,
host: Host,
events: Option<Arc<Latest<DebugEvent>>>,
) -> io::Result<Self> {
let instance_id = instance_id();
let descriptor_path = descriptor_path(&instance_id);
let socket_path = descriptor_path.with_extension("sock");
if let Some(parent) = socket_path.parent() {
std::fs::create_dir_all(parent)?;
std::fs::set_permissions(parent, std::fs::Permissions::from_mode(0o700))?;
}
let _ = remove_file(&socket_path);
let addr = Addr::path(socket_path.as_os_str().as_bytes())
.map_err(|_| io::Error::other("socket path is not a valid unix address"))?;
let listener = BoundListener::bind(addr, 128)
.map_err(|error| io::Error::other(format!("bind: {error:?}")))?;
std::fs::set_permissions(&socket_path, std::fs::Permissions::from_mode(0o600))?;
let descriptor = DebugDescriptor {
protocol_version: crate::DEBUG_PROTOCOL_VERSION,
pid: std::process::id(),
instance_id,
address: format!("unix://{}", socket_path.display()),
renderer: "blitz".into(),
renderer_revision: host.version.clone(),
};
write_descriptor(&descriptor_path, &descriptor)?;
reap_dead_descriptors(&descriptor_path);
let shutdown_flag = Flag::new();
let shutdown_for_thread = Arc::clone(&shutdown_flag);
let thread = thread::Builder::new()
.name("blitz-agent-control".into())
.spawn(move || run(listener, bridge, host, events, shutdown_for_thread))?;
Ok(Self {
descriptor_path,
socket_path,
shutdown: Some(shutdown_flag),
thread: Some(thread),
#[cfg(feature = "capture")]
_sampling: blitz_shell::begin_deep_profiling(),
})
}
pub fn descriptor_path(&self) -> &Path {
&self.descriptor_path
}
#[cfg(feature = "capture")]
pub fn refresh_deep_profiling(&mut self) {
self._sampling = blitz_shell::begin_deep_profiling();
}
pub fn socket_path(&self) -> &Path {
&self.socket_path
}
}
impl Drop for AgentControlServer {
fn drop(&mut self) {
if let Some(shutdown) = self.shutdown.take() {
shutdown.raise();
}
if let Some(thread) = self.thread.take() {
let _ = thread.join();
}
let _ = remove_file(&self.socket_path);
let _ = remove_file(&self.descriptor_path);
}
}
fn run(
listener: BoundListener,
bridge: ControlBridge,
host: Host,
events: Option<Arc<Latest<DebugEvent>>>,
shutdown: Arc<Flag>,
) {
let reactor = match Reactor::local() {
Ok(reactor) => reactor,
Err(error) => {
eprintln!("control socket reactor could not start: {error:?}");
return;
}
};
let handle = reactor.handle();
let listener = match TcpListener::from_listener(listener, &handle) {
Ok(listener) => listener,
Err(error) => {
eprintln!("control socket could not register on the reactor: {error:?}");
return;
}
};
block_on_with(&reactor, async move {
use futures::StreamExt;
use futures::future::{Either, select};
use futures::stream::FuturesUnordered;
let mut connections = FuturesUnordered::new();
loop {
let stopping = shutdown.raised();
let accepted = listener.accept();
futures::pin_mut!(stopping, accepted);
let accepted = if connections.is_empty() {
match select(stopping, accepted).await {
Either::Left(_) => break,
Either::Right((accepted, _)) => accepted,
}
} else {
let progress = select(accepted, connections.next());
futures::pin_mut!(progress);
match select(stopping, progress).await {
Either::Left(_) => break,
Either::Right((Either::Left((accepted, _)), _)) => accepted,
Either::Right((Either::Right(_), _)) => continue,
}
};
let Ok((stream, _)) = accepted else {
break;
};
connections.push(handle_connection(
stream,
Arc::clone(&bridge),
host.clone(),
events.clone(),
));
}
});
}
enum ConnectionInput {
Message(Option<Result<WireMessage, StreamError>>),
Event(DebugEvent),
}
fn stream_wants_event(streams: &[DebugStream], event: &DebugEvent) -> bool {
match event {
DebugEvent::Snapshot(_) => streams.contains(&DebugStream::Snapshots),
DebugEvent::Metrics(_) => streams.contains(&DebugStream::Metrics),
DebugEvent::Console(_) => streams.contains(&DebugStream::Console),
DebugEvent::RuntimeError(_) => streams.contains(&DebugStream::RuntimeErrors),
DebugEvent::PaintCommitted { .. } => streams.contains(&DebugStream::Paint),
}
}
async fn handle_connection(
stream: TcpStream,
bridge: ControlBridge,
host: Host,
events: Option<Arc<Latest<DebugEvent>>>,
) {
let mut stream = TransportStream::new(framed_json_neutral(NagoyaStream::new(stream)));
let mut observed = Vec::<DebugStream>::new();
let mut seen = events.as_ref().map_or(0, |latest| latest.revision());
loop {
let input = if observed.is_empty() {
ConnectionInput::Message(stream.recv().await)
} else if let Some(latest) = events.as_ref() {
use futures::future::{Either, select};
let message = stream.recv();
let changed = latest.changed_since(seen);
futures::pin_mut!(message, changed);
match select(message, changed).await {
Either::Left((message, _)) => ConnectionInput::Message(message),
Either::Right(((event, revision), _)) => {
seen = revision;
match event {
Some(event) => ConnectionInput::Event(event),
None => continue,
}
}
}
} else {
ConnectionInput::Message(stream.recv().await)
};
let message = match input {
ConnectionInput::Event(event) => {
if !stream_wants_event(&observed, &event) {
continue;
}
let Ok(frame) = encode_diagnostics_event(&event) else {
continue;
};
if stream.send(frame).await.is_err() {
break;
}
continue;
}
ConnectionInput::Message(Some(message)) => message,
ConnectionInput::Message(None) => break,
};
let response = match message {
Ok(message) => match decode_wire_value(message) {
Ok(value) => {
let request_id = peek_value_request_id(&value);
match decode_incoming_value(value) {
Ok(IncomingRequest::Initialize { id }) => {
encode_initialize_response(id, &host.name, &host.version)
}
Ok(IncomingRequest::Initialized) => continue,
Ok(IncomingRequest::ToolsList { id }) => {
encode_tools_list_response(id, host.diagnostics)
}
Ok(IncomingRequest::Agent { id, request }) => {
let response = bridge(ControlBridgeRequest::Agent(request))
.recv()
.await
.unwrap_or_else(|| {
DebugResponse::Error(crate::DebugError {
code: "bridgeClosed".into(),
message: "the UI-thread control bridge closed".into(),
})
});
encode_response(id, &response)
}
Ok(IncomingRequest::Diagnostics {
id,
request: DiagnosticsRequest::Observe { streams },
}) => {
observed = streams;
if let Some(latest) = events.as_ref() {
seen = latest.revision();
}
encode_response(id, &DebugResponse::Ack)
}
Ok(IncomingRequest::Diagnostics { id, request }) => {
let response = bridge(ControlBridgeRequest::Diagnostics(request))
.recv()
.await
.unwrap_or_else(|| {
DebugResponse::Error(crate::DebugError {
code: "bridgeClosed".into(),
message: "the UI-thread diagnostics bridge closed".into(),
})
});
encode_response(id, &response)
}
Err(error) => encode_rpc_error(
request_id,
JsonRpcError::new(INVALID_REQUEST, error.to_string()),
),
}
}
Err(error) => {
encode_rpc_error(None, JsonRpcError::new(INVALID_REQUEST, error.to_string()))
}
},
Err(error) => {
let farewell =
encode_rpc_error(None, JsonRpcError::new(INVALID_REQUEST, error.to_string()));
if let Ok(farewell) = farewell {
let _ = stream.send(farewell).await;
}
break;
}
};
let response = response.unwrap_or_else(|error| {
encode_rpc_error(
None,
JsonRpcError::new(
INVALID_REQUEST,
format!("could not encode response: {error}"),
),
)
.expect("the fallback JSON-RPC error is serializable")
});
if stream.send(response).await.is_err() {
break;
}
}
}
fn instance_id() -> String {
let nanos = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
format!("{}-{nanos:x}", std::process::id())
}
fn pid_is_live(pid: u32) -> bool {
std::process::Command::new("ps")
.args(["-p", &pid.to_string()])
.output()
.map(|out| out.status.success())
.unwrap_or(true)
}
fn reap_dead_descriptors(own: &Path) {
reap_dead_descriptors_with(own, pid_is_live);
}
fn reap_dead_descriptors_with(own: &Path, is_live: impl Fn(u32) -> bool) {
let Some(dir) = own.parent() else { return };
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if path == own || path.extension().is_none_or(|ext| ext != "json") {
continue;
}
let Ok(text) = std::fs::read_to_string(&path) else {
continue;
};
let Ok(descriptor) = serde_json::from_str::<DebugDescriptor>(&text) else {
continue;
};
if is_live(descriptor.pid) {
continue;
}
let _ = remove_file(path.with_extension("sock"));
let _ = remove_file(&path);
}
}
fn descriptor_path(instance_id: &str) -> PathBuf {
std::env::temp_dir()
.join("tauri-blitz-agent")
.join(format!("{instance_id}.json"))
}
fn write_descriptor(path: &Path, descriptor: &DebugDescriptor) -> io::Result<()> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let mut file = OpenOptions::new()
.create(true)
.truncate(true)
.write(true)
.mode(0o600)
.open(path)?;
serde_json::to_writer_pretty(&mut file, descriptor).map_err(io::Error::other)?;
file.write_all(b"\n")?;
file.sync_all()
}
#[cfg(test)]
mod tests {
use endpoint_libs::libs::ws::mcp_wire::{JsonRpcId, JsonRpcMessage, JsonRpcRequest};
use super::*;
use crate::{
AgentAction, AgentControlRequest, DebugResponse, MCP_INITIALIZE, MCP_TOOLS_LIST,
decode_response, decode_rpc, encode_agent_request, encode_rpc,
};
use crate::{
DebugEvent, DebugSnapshot, DebugStream, DiagnosticsRequest, RendererMetrics, RevisionSet,
SnapshotRequest, decode_diagnostics_event, encode_diagnostics_request,
};
async fn connect(path: &Path) -> NagoyaStream {
static CLIENT_REACTOR: std::sync::OnceLock<(Reactor, nagoya::reactor::Handle)> =
std::sync::OnceLock::new();
let (_, handle) = CLIENT_REACTOR.get_or_init(|| {
let reactor = Reactor::start().expect("client reactor");
let handle = reactor.handle();
(reactor, handle)
});
let addr = Addr::path(path.as_os_str().as_bytes()).expect("socket path");
let stream = TcpStream::connect(addr, handle).await.expect("connect");
NagoyaStream::new(stream)
}
fn test_host() -> Host {
Host {
name: "test-host".into(),
version: "0.0.0".into(),
diagnostics: true,
}
}
#[test]
fn local_server_is_mcp_compatible_and_needs_no_session_or_token() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|request| {
let answer = Once::new();
assert!(matches!(
request,
ControlBridgeRequest::Agent(AgentControlRequest::Act(AgentAction::Click {
node_id: 42
}))
));
answer.fill(DebugResponse::Ack);
answer
});
let server = AgentControlServer::start(bridge, test_host()).unwrap();
assert!(server.descriptor_path().is_file());
assert_eq!(
server
.descriptor_path()
.metadata()
.unwrap()
.permissions()
.mode()
& 0o777,
0o600
);
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
stream
.send(
encode_rpc(JsonRpcMessage::Request(JsonRpcRequest::call(
JsonRpcId::Number(1),
MCP_INITIALIZE,
serde_json::json!({"protocolVersion": "2025-06-18"}),
)))
.unwrap(),
)
.await
.unwrap();
assert!(matches!(
decode_rpc(stream.recv().await.unwrap().unwrap()).unwrap(),
JsonRpcMessage::Response(_)
));
stream
.send(
encode_rpc(JsonRpcMessage::Request(JsonRpcRequest::call(
JsonRpcId::Number(2),
MCP_TOOLS_LIST,
serde_json::json!({}),
)))
.unwrap(),
)
.await
.unwrap();
assert!(matches!(
decode_rpc(stream.recv().await.unwrap().unwrap()).unwrap(),
JsonRpcMessage::Response(_)
));
let id = JsonRpcId::Number(42);
stream
.send(
encode_agent_request(
id.clone(),
&AgentControlRequest::Act(AgentAction::Click { node_id: 42 }),
)
.unwrap(),
)
.await
.unwrap();
let response = stream.recv().await.unwrap().unwrap();
assert_eq!(decode_response(response).unwrap(), (id, DebugResponse::Ack));
let second = connect(server.socket_path()).await;
let mut second = TransportStream::new(framed_json_neutral(second));
let id = JsonRpcId::String("second-observer".into());
second
.send(
encode_agent_request(
id.clone(),
&AgentControlRequest::Act(AgentAction::Click { node_id: 42 }),
)
.unwrap(),
)
.await
.unwrap();
assert_eq!(
decode_response(second.recv().await.unwrap().unwrap()).unwrap(),
(id, DebugResponse::Ack)
);
drop(server);
});
}
#[test]
fn diagnostics_metrics_reach_the_runtime_bridge_over_mcp() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|request| {
let answer = Once::new();
assert!(matches!(
request,
ControlBridgeRequest::Diagnostics(DiagnosticsRequest::Metrics)
));
answer.fill(DebugResponse::Metrics(RendererMetrics {
resident_bytes: Some(8192),
..Default::default()
}));
answer
});
let server = AgentControlServer::start(bridge, test_host()).unwrap();
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
let id = JsonRpcId::Number(91);
stream
.send(encode_diagnostics_request(id.clone(), &DiagnosticsRequest::Metrics).unwrap())
.await
.unwrap();
assert_eq!(
decode_response(stream.recv().await.unwrap().unwrap()).unwrap(),
(
id,
DebugResponse::Metrics(RendererMetrics {
resident_bytes: Some(8192),
..Default::default()
})
)
);
});
}
#[test]
fn observe_pushes_only_requested_latest_value_events() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|_request| {
panic!("observe is connection-local and must not reach the UI bridge")
});
let events = Latest::new();
let server =
AgentControlServer::start_with_events(bridge, test_host(), Arc::clone(&events))
.unwrap();
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
let id = JsonRpcId::Number(92);
stream
.send(
encode_diagnostics_request(
id.clone(),
&DiagnosticsRequest::Observe {
streams: vec![DebugStream::Paint],
},
)
.unwrap(),
)
.await
.unwrap();
assert_eq!(
decode_response(stream.recv().await.unwrap().unwrap()).unwrap(),
(id, DebugResponse::Ack)
);
let event = DebugEvent::PaintCommitted { revision: 7 };
events.set(event.clone()).await;
assert_eq!(
decode_diagnostics_event(stream.recv().await.unwrap().unwrap()).unwrap(),
event
);
});
}
#[test]
fn large_snapshot_keeps_the_socket_open_for_follow_up_requests() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
const LARGE_DOM_BYTES: usize = 9 * 1024 * 1024;
let bridge: ControlBridge = Arc::new(|request| {
let answer = Once::new();
let response = match request {
ControlBridgeRequest::Diagnostics(DiagnosticsRequest::Snapshot(_)) => {
DebugResponse::Snapshot(DebugSnapshot {
revisions: RevisionSet::default(),
active_window: Some("main".into()),
active_element: None,
dom: Some(serde_json::Value::String("x".repeat(LARGE_DOM_BYTES))),
layout: None,
computed_style: None,
metrics: RendererMetrics::default(),
})
}
ControlBridgeRequest::Diagnostics(DiagnosticsRequest::Metrics) => {
DebugResponse::Metrics(RendererMetrics {
resident_bytes: Some(4096),
..Default::default()
})
}
_ => panic!("unexpected request"),
};
answer.fill(response);
answer
});
let server = AgentControlServer::start(bridge, test_host()).unwrap();
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
let snapshot_id = JsonRpcId::Number(92);
stream
.send(
encode_diagnostics_request(
snapshot_id.clone(),
&DiagnosticsRequest::Snapshot(SnapshotRequest {
include_dom: true,
include_layout: false,
include_computed_style: false,
node_ids: Vec::new(),
}),
)
.unwrap(),
)
.await
.unwrap();
let (response_id, response) =
decode_response(stream.recv().await.unwrap().unwrap()).unwrap();
assert_eq!(response_id, snapshot_id);
let DebugResponse::Snapshot(snapshot) = response else {
panic!("expected a diagnostic snapshot")
};
assert_eq!(
snapshot.dom.unwrap().as_str().unwrap().len(),
LARGE_DOM_BYTES
);
let metrics_id = JsonRpcId::Number(93);
stream
.send(
encode_diagnostics_request(metrics_id.clone(), &DiagnosticsRequest::Metrics)
.unwrap(),
)
.await
.unwrap();
assert_eq!(
decode_response(stream.recv().await.unwrap().unwrap()).unwrap(),
(
metrics_id,
DebugResponse::Metrics(RendererMetrics {
resident_bytes: Some(4096),
..Default::default()
})
)
);
});
}
#[test]
fn initialize_payload_uses_json_rpc() {
let message =
encode_initialize_response(JsonRpcId::Number(1), "test-host", "0.1.0").unwrap();
let WireMessage::Text(payload) = message else {
panic!("initialize response must be text")
};
let decoded: JsonRpcMessage = serde_json::from_str(&payload).unwrap();
assert!(matches!(decoded, JsonRpcMessage::Response(_)));
}
#[test]
fn reaping_removes_dead_descriptors_and_spares_live_ones() {
let dir = std::env::temp_dir().join(format!(
"blitz-reap-{}-{:x}",
std::process::id(),
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
));
std::fs::create_dir_all(&dir).expect("scratch directory is created");
let write = |name: &str, pid: u32| {
let path = dir.join(format!("{name}.json"));
write_descriptor(
&path,
&DebugDescriptor {
protocol_version: crate::DEBUG_PROTOCOL_VERSION,
pid,
instance_id: name.into(),
address: format!("unix://{}", dir.join(format!("{name}.sock")).display()),
renderer: "blitz".into(),
renderer_revision: "0.0.0".into(),
},
)
.expect("descriptor is written");
std::fs::write(dir.join(format!("{name}.sock")), b"").expect("socket stub is written");
path
};
let own = write("own", std::process::id());
let live = write("live", 1);
let dead = write("dead", 2);
reap_dead_descriptors_with(&own, |pid| pid == std::process::id() || pid == 1);
assert!(own.exists(), "the caller's own descriptor is never reaped");
assert!(live.exists(), "a live instance must keep its descriptor");
assert!(!dead.exists(), "a dead instance's descriptor is removed");
assert!(
!dir.join("dead.sock").exists(),
"the orphaned socket goes with it"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn teardown_removes_the_socket_and_the_descriptor() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|_request| {
let answer = Once::new();
answer.fill(DebugResponse::Ack);
answer
});
let server = AgentControlServer::start(bridge, test_host()).unwrap();
let descriptor = server.descriptor_path().to_path_buf();
let socket = server.socket_path().to_path_buf();
assert!(descriptor.is_file(), "the descriptor was not published");
assert!(socket.exists(), "the socket was not bound");
drop(server);
assert!(!socket.exists(), "the socket outlived the server");
assert!(
!descriptor.exists(),
"the descriptor outlived the server, so a client can still find it"
);
});
}
#[test]
fn a_host_that_cannot_collect_diagnostics_does_not_advertise_them() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|_request| {
let answer = Once::new();
answer.fill(DebugResponse::Ack);
answer
});
let server = AgentControlServer::start(
bridge,
Host {
name: "plain-host".into(),
version: "9.9.9".into(),
diagnostics: false,
},
)
.unwrap();
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
stream
.send(
encode_rpc(JsonRpcMessage::Request(JsonRpcRequest::call(
JsonRpcId::Number(1),
MCP_TOOLS_LIST,
serde_json::json!({}),
)))
.unwrap(),
)
.await
.unwrap();
let JsonRpcMessage::Response(response) =
decode_rpc(stream.recv().await.unwrap().unwrap()).unwrap()
else {
panic!("tools/list should be a response")
};
let tools = response.result.unwrap()["tools"].as_array().unwrap().len();
assert_eq!(
tools, 1,
"a host that cannot collect diagnostics must not offer the tool: \
a client reports the application as broken rather than as a plain \
build"
);
});
}
#[test]
fn initialize_reports_the_host_rather_than_the_transport() {
nagoya::block_on(async {
let _guard = CONTROL_TEST_LOCK.write().await;
let bridge: ControlBridge = Arc::new(|_request| {
let answer = Once::new();
answer.fill(DebugResponse::Ack);
answer
});
let server = AgentControlServer::start(
bridge,
Host {
name: "chuzz-headless".into(),
version: "1.2.3".into(),
diagnostics: true,
},
)
.unwrap();
let stream = connect(server.socket_path()).await;
let mut stream = TransportStream::new(framed_json_neutral(stream));
stream
.send(
encode_rpc(JsonRpcMessage::Request(JsonRpcRequest::call(
JsonRpcId::Number(1),
MCP_INITIALIZE,
serde_json::json!({"protocolVersion": "2025-06-18"}),
)))
.unwrap(),
)
.await
.unwrap();
let JsonRpcMessage::Response(response) =
decode_rpc(stream.recv().await.unwrap().unwrap()).unwrap()
else {
panic!("initialize should be a response")
};
let result = response.result.unwrap();
assert_eq!(result["serverInfo"]["name"], "chuzz-headless");
assert_eq!(result["serverInfo"]["version"], "1.2.3");
let descriptor: DebugDescriptor =
serde_json::from_str(&std::fs::read_to_string(server.descriptor_path()).unwrap())
.unwrap();
assert_eq!(
descriptor.renderer_revision, "1.2.3",
"the descriptor reports the host's version, not the protocol crate's"
);
});
}
}