use indexmap::IndexMap;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.IdentifyMount")]
pub struct IdentifyMount {
pub host: String,
pub container: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.Identify")]
pub struct Identify {
pub id: String,
pub image: crate::laboratories::LaboratoryImage,
pub mounts: Vec<IdentifyMount>,
pub env: Vec<[String; 2]>,
pub cwd: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub created_at: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub agent_full_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub plugin: Option<IdentifyPlugin>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub response_id: Option<String>,
#[serde(default)]
pub running: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.IdentifyPlugin")]
pub struct IdentifyPlugin {
pub owner: String,
pub name: String,
pub version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.HostIdentify")]
pub struct HostIdentify {
pub state: String,
pub machine: crate::machine::MachineIdentity,
pub laboratories: Vec<Identify>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.ChannelRequest")]
pub struct ChannelRequest {
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub laboratory_id: Option<String>,
pub headers: IndexMap<String, String>,
pub payload: super::RequestPayload,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.ChannelResponse")]
pub struct ChannelResponse {
pub id: String,
pub payload: super::ResponsePayload,
}
impl ChannelRequest {
fn wire_payload(&self) -> Option<&[u8]> {
match &self.payload {
super::RequestPayload::ImportWrite(req) => Some(&req.data),
_ => None,
}
}
pub fn to_wire(
&self,
) -> Result<crate::binary_frame::WireFrame, serde_json::Error> {
let header = serde_json::to_string(self)?;
Ok(match self.wire_payload() {
None => crate::binary_frame::WireFrame::Text(header),
Some(payload) => crate::binary_frame::WireFrame::Binary(
crate::binary_frame::encode(&header, payload),
),
})
}
pub fn from_binary(frame: &[u8]) -> Option<Self> {
let (header, payload) = crate::binary_frame::decode(frame)?;
let mut parsed: Self = serde_json::from_str(header).ok()?;
match &mut parsed.payload {
super::RequestPayload::ImportWrite(req) => {
req.data = payload.to_vec();
Some(parsed)
}
_ => None,
}
}
}
impl ChannelResponse {
fn wire_payload(&self) -> Option<&[u8]> {
match &self.payload {
super::ResponsePayload::ExportRead(super::JsonRpcResult::Ok {
result,
})
| super::ResponsePayload::BuildRead(super::JsonRpcResult::Ok {
result,
}) => Some(&result.data),
_ => None,
}
}
pub fn to_wire(
&self,
) -> Result<crate::binary_frame::WireFrame, serde_json::Error> {
let header = serde_json::to_string(self)?;
Ok(match self.wire_payload() {
None => crate::binary_frame::WireFrame::Text(header),
Some(payload) => crate::binary_frame::WireFrame::Binary(
crate::binary_frame::encode(&header, payload),
),
})
}
pub fn from_binary(frame: &[u8]) -> Option<Self> {
let (header, payload) = crate::binary_frame::decode(frame)?;
let mut parsed: Self = serde_json::from_str(header).ok()?;
match &mut parsed.payload {
super::ResponsePayload::ExportRead(super::JsonRpcResult::Ok {
result,
})
| super::ResponsePayload::BuildRead(super::JsonRpcResult::Ok {
result,
}) => {
result.data = payload.to_vec();
Some(parsed)
}
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.HostNotification")]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum HostNotification {
#[schemars(title = "LaboratoryCreated")]
LaboratoryCreated { laboratory: Identify },
#[schemars(title = "LaboratoryUpdated")]
LaboratoryUpdated { laboratory: Identify },
#[schemars(title = "LaboratoryDeleted")]
LaboratoryDeleted { id: String },
#[schemars(title = "LaboratoryFiletree")]
LaboratoryFiletree {
id: String,
event: crate::laboratories::filetree::FileTreeEvent,
},
#[schemars(title = "McpListChanged")]
McpListChanged {
id: String,
response_id: String,
kind: McpListChangedKind,
},
}
#[derive(
Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema,
)]
#[schemars(rename = "laboratories.daemon.McpListChangedKind")]
#[serde(rename_all = "snake_case")]
pub enum McpListChangedKind {
Tools,
Resources,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.HostCommandRequest")]
pub struct HostCommandRequest {
pub id: String,
pub identity: crate::identity::Identity,
pub plugin: crate::mcp::server::Plugin,
pub request: crate::cli::command::Request,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.HostCommandResponse")]
pub struct HostCommandResponse {
pub id: String,
#[serde(flatten)]
pub frame: CommandFrame,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.CommandFrame")]
#[serde(tag = "frame", rename_all = "snake_case")]
pub enum CommandFrame {
Ack,
Item {
item: crate::cli::command::ResponseItem,
},
Error { error: String },
Done,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.HostPostgres")]
#[serde(tag = "postgres", rename_all = "snake_case")]
pub enum HostPostgres {
Open { stream_id: String },
Close { stream_id: String },
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.DaemonPostgres")]
#[serde(tag = "postgres", rename_all = "snake_case")]
pub enum DaemonPostgres {
Close { stream_id: String },
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "laboratories.daemon.PostgresData")]
pub struct PostgresData {
pub stream_id: String,
#[serde(skip)]
pub bytes: Vec<u8>,
}
impl PostgresData {
pub fn to_wire(
&self,
) -> Result<crate::binary_frame::WireFrame, serde_json::Error> {
let header = serde_json::to_string(self)?;
Ok(crate::binary_frame::WireFrame::Binary(
crate::binary_frame::encode(&header, &self.bytes),
))
}
pub fn from_binary(frame: &[u8]) -> Option<Self> {
let (header, payload) = crate::binary_frame::decode(frame)?;
let mut parsed: Self = serde_json::from_str(header).ok()?;
parsed.bytes = payload.to_vec();
Some(parsed)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn host_command_request_is_not_a_channel_response() {
let request = HostCommandRequest {
id: "cmd-1".to_string(),
identity: Default::default(),
plugin: crate::mcp::server::Plugin {
owner: "acme".to_string(),
name: "widgets".to_string(),
version: "1.2.3".to_string(),
},
request: crate::cli::command::Request::Update(
crate::cli::command::update::Request {
path_type: crate::cli::command::update::Path::Update,
base: crate::cli::command::RequestBase {
jq: None,
python: None,
timeout_seconds: None,
max_tokens: None,
},
},
),
};
let text = serde_json::to_string(&request).unwrap();
assert!(serde_json::from_str::<ChannelResponse>(&text).is_err());
let parsed: HostCommandRequest = serde_json::from_str(&text).unwrap();
assert_eq!(parsed.id, "cmd-1");
assert_eq!(parsed.plugin.owner, "acme");
}
#[test]
fn host_command_response_wire_shape() {
let ack = HostCommandResponse {
id: "cmd-1".to_string(),
frame: CommandFrame::Ack,
};
assert_eq!(
serde_json::to_string(&ack).unwrap(),
r#"{"id":"cmd-1","frame":"ack"}"#,
);
let error = HostCommandResponse {
id: "cmd-1".to_string(),
frame: CommandFrame::Error {
error: "boom".to_string(),
},
};
assert_eq!(
serde_json::to_string(&error).unwrap(),
r#"{"id":"cmd-1","frame":"error","error":"boom"}"#,
);
let done: HostCommandResponse =
serde_json::from_str(r#"{"id":"cmd-1","frame":"done"}"#).unwrap();
assert!(matches!(done.frame, CommandFrame::Done));
}
#[test]
fn host_postgres_open_is_disjoint() {
let open = HostPostgres::Open {
stream_id: "pg-1".to_string(),
};
let text = serde_json::to_string(&open).unwrap();
assert_eq!(text, r#"{"postgres":"open","stream_id":"pg-1"}"#);
assert!(serde_json::from_str::<ChannelResponse>(&text).is_err());
assert!(serde_json::from_str::<ChannelRequest>(&text).is_err());
assert!(serde_json::from_str::<HostCommandRequest>(&text).is_err());
assert!(serde_json::from_str::<HostNotification>(&text).is_err());
}
#[test]
fn postgres_data_binary_round_trip() {
let data = PostgresData {
stream_id: "pg-1".to_string(),
bytes: vec![0, 1, 2, 255, 254],
};
let crate::binary_frame::WireFrame::Binary(frame) = data.to_wire().unwrap()
else {
panic!("PostgresData must serialize as a binary sandwich");
};
let parsed = PostgresData::from_binary(&frame).unwrap();
assert_eq!(parsed.stream_id, "pg-1");
assert_eq!(parsed.bytes, vec![0, 1, 2, 255, 254]);
let chan = ChannelResponse {
id: "c-1".to_string(),
payload: super::super::ResponsePayload::ExportRead(
super::super::JsonRpcResult::Ok {
result: super::super::ExportChunk {
data: vec![9, 9, 9],
eof: false,
},
},
),
};
let crate::binary_frame::WireFrame::Binary(chan_frame) =
chan.to_wire().unwrap()
else {
panic!("chunk-bearing ChannelResponse is binary");
};
assert!(PostgresData::from_binary(&chan_frame).is_none());
}
}