use serde::{Deserialize, Serialize};
use wist_contracts::capability_report::LogsCapabilities;
use super::{AgentLocalWork, AgentUplinkState, HostProfile};
pub const API_VERSION: &str = wist_contracts::API_VERSION_V1;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AgentWorkState {
Paused,
Resumed,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentWorkStateChange {
pub input_id: String,
pub state: AgentWorkState,
pub reason: String,
pub at: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentStatusReport {
pub agent_id: String,
pub instance_id: String,
pub version: String,
#[serde(default)]
pub memory_bytes: Option<u64>,
#[serde(default)]
pub cpu_percent: Option<f64>,
#[serde(default)]
pub cpu_cores: Option<u32>,
#[serde(default)]
pub admin_latency_ms: Option<u64>,
#[serde(default)]
pub work_state_changes: Option<Vec<AgentWorkStateChange>>,
#[serde(default)]
pub discovery_policy_version: Option<i64>,
#[serde(default)]
pub local_work: Option<AgentLocalWork>,
#[serde(default)]
pub uplink_state: Option<AgentUplinkState>,
#[serde(default)]
pub certificate_status: Option<AgentCertificateStatus>,
#[serde(default)]
pub machine_profile: Option<HostProfile>,
#[serde(default)]
pub logs_capabilities: Option<LogsCapabilities>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub command_acks: Vec<AgentCommandAck>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentCertificateStatus {
pub not_after: String,
pub remaining_seconds: i64,
pub state: String,
#[serde(default)]
pub last_renewal: Option<AgentCredentialRenewal>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentCredentialRenewal {
pub outcome: String,
pub checked_at: String,
pub detail: String,
pub not_after: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentStatusAck {
pub agent_id: String,
pub instance_id: String,
pub acknowledged_at: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub commands: Vec<AgentCommand>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentCommand {
pub command_id: String,
pub requested_at_ms: i64,
pub kind: String,
#[serde(default, skip_serializing_if = "String::is_empty")]
pub params: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AgentCommandAck {
pub command_id: String,
pub outcome: String,
#[serde(default, skip_serializing_if = "String::is_empty")]
pub detail: String,
}
pub mod command_kind {
pub const REFRESH_FACTS: &str = "refresh_facts";
}
pub mod command_outcome {
pub const SUCCEEDED: &str = "succeeded";
pub const FAILED: &str = "failed";
pub const NO_UPLINK: &str = "no_uplink";
pub const THROTTLED: &str = "throttled";
pub const STALE: &str = "stale";
pub const UNSUPPORTED: &str = "unsupported";
pub const SUPERSEDED: &str = "superseded";
pub const EXPIRED: &str = "expired";
}
#[cfg(test)]
mod tests {
use super::{
AgentCertificateStatus, AgentCommandAck, AgentStatusAck, AgentStatusReport, AgentWorkState,
AgentWorkStateChange, command_outcome,
};
#[test]
fn agent_work_state_uses_snake_case_on_the_wire() {
assert_eq!(
serde_json::to_string(&AgentWorkState::Paused).unwrap(),
"\"paused\""
);
assert_eq!(
serde_json::to_string(&AgentWorkState::Resumed).unwrap(),
"\"resumed\""
);
let change = AgentWorkStateChange {
input_id: "app".to_string(),
state: AgentWorkState::Paused,
reason: "spool_over_limit".to_string(),
at: "2026-09-27T00:00:00Z".to_string(),
};
let json = serde_json::to_string(&change).expect("encode");
let back: AgentWorkStateChange = serde_json::from_str(&json).expect("decode");
assert_eq!(back, change);
let mutated = json.replacen('{', "{\"extra\":1,", 1);
assert!(serde_json::from_str::<AgentWorkStateChange>(&mutated).is_err());
}
#[test]
fn a_minimal_agent_status_report_decodes_and_extra_keys_fail() {
let json = r#"{"agent_id":"a","instance_id":"i","version":"0.1.5"}"#;
let report: AgentStatusReport = serde_json::from_str(json).expect("decode");
assert_eq!(report.memory_bytes, None);
assert_eq!(report.cpu_percent, None);
assert_eq!(report.work_state_changes, None);
assert_eq!(report.discovery_policy_version, None);
assert!(report.local_work.is_none());
assert!(report.uplink_state.is_none());
assert!(report.certificate_status.is_none());
assert!(report.machine_profile.is_none());
assert!(report.command_acks.is_empty());
assert!(
serde_json::from_str::<AgentStatusReport>(
r#"{"agent_id":"a","instance_id":"i","version":"v","nope":1}"#
)
.is_err()
);
}
#[test]
fn an_agent_status_report_carries_the_machine_profile() {
let json = r#"{
"agent_id":"a","instance_id":"i","version":"0.1.24",
"machine_profile":{
"node_id":"node-1","hostname":"host-1","os":"linux","arch":"x86_64",
"machine_id":"mid-1","cloud_instance_id":null,"k8s_node_uid":null,
"ip_addresses":["en0 192.168.1.5/24","10.8.0.2"]
}
}"#;
let report: AgentStatusReport = serde_json::from_str(json).expect("decode");
let profile = report.machine_profile.expect("machine_profile present");
assert_eq!(profile.hostname, "host-1");
assert_eq!(profile.node_id, "node-1");
assert_eq!(profile.machine_id, "mid-1");
assert_eq!(
profile.ip_addresses,
vec!["en0 192.168.1.5/24".to_string(), "10.8.0.2".to_string()]
);
}
#[test]
fn certificate_status_last_renewal_is_optional_and_round_trips() {
let legacy =
r#"{"not_after":"2026-11-04T00:00:00Z","remaining_seconds":100,"state":"valid"}"#;
let status: AgentCertificateStatus = serde_json::from_str(legacy).expect("decode");
assert!(status.last_renewal.is_none());
let json = r#"{"not_after":"2026-11-04T00:00:00Z","remaining_seconds":100,"state":"valid",
"last_renewal":{"outcome":"renewed","checked_at":"2026-10-08T00:00:00Z",
"detail":"credential renewed","not_after":"2026-11-04T00:00:00Z"}}"#;
let status: AgentCertificateStatus = serde_json::from_str(json).expect("decode");
assert_eq!(
status.last_renewal.as_ref().expect("renewal").outcome,
"renewed"
);
let encoded = serde_json::to_string(&status).expect("encode");
let back: AgentCertificateStatus = serde_json::from_str(&encoded).expect("decode");
assert_eq!(back, status);
let drifted = r#"{"not_after":"x","remaining_seconds":0,"state":"valid",
"last_renewal":{"outcome":"renewed","checked_at":"t","detail":"","not_after":"",
"extra":1}}"#;
assert!(serde_json::from_str::<AgentCertificateStatus>(drifted).is_err());
}
#[test]
fn logs_capabilities_are_optional_and_round_trip() {
let legacy = r#"{"agent_id":"a","instance_id":"i","version":"0.8.0"}"#;
let report: AgentStatusReport = serde_json::from_str(legacy).expect("decode");
assert!(report.logs_capabilities.is_none());
let json = r#"{"agent_id":"a","instance_id":"i","version":"0.9.0",
"logs_capabilities":{
"file_inputs":["absolute-path","glob"],
"multiline_modes":["none","indented"],
"exporters":["journalctl-kernel"]
}}"#;
let report: AgentStatusReport = serde_json::from_str(json).expect("decode");
let logs = report.logs_capabilities.expect("logs_capabilities");
assert_eq!(logs.exporters, vec!["journalctl-kernel".to_string()]);
assert!(logs.file_inputs.contains(&"glob".to_string()));
let drifted = r#"{"agent_id":"a","instance_id":"i","version":"v",
"logs_capabilities":{"file_inputs":[],"nope":1}}"#;
assert!(serde_json::from_str::<AgentStatusReport>(drifted).is_err());
}
#[test]
fn a_status_ack_carries_optional_commands() {
let legacy = r#"{"agent_id":"a","instance_id":"i","acknowledged_at":"t"}"#;
let ack: AgentStatusAck = serde_json::from_str(legacy).expect("decode");
assert!(ack.commands.is_empty());
let json = r#"{"agent_id":"a","instance_id":"i","acknowledged_at":"t",
"commands":[{"command_id":"c-1","requested_at_ms":1700000000000,
"kind":"refresh_facts"}]}"#;
let ack: AgentStatusAck = serde_json::from_str(json).expect("decode");
assert_eq!(ack.commands.len(), 1);
let command = &ack.commands[0];
assert_eq!(command.command_id, "c-1");
assert_eq!(command.requested_at_ms, 1_700_000_000_000);
assert_eq!(command.kind, "refresh_facts");
assert!(command.params.is_empty());
let encoded = serde_json::to_string(&AgentStatusAck {
agent_id: "a".to_string(),
instance_id: "i".to_string(),
acknowledged_at: "t".to_string(),
commands: Vec::new(),
})
.expect("encode");
assert!(!encoded.contains("commands"));
let drifted = r#"{"agent_id":"a","instance_id":"i","acknowledged_at":"t",
"commands":[{"command_id":"c-1","requested_at_ms":1,
"kind":"refresh_facts","nope":1}]}"#;
assert!(serde_json::from_str::<AgentStatusAck>(drifted).is_err());
}
#[test]
fn an_unknown_command_kind_still_decodes() {
let json = r#"{"agent_id":"a","instance_id":"i","acknowledged_at":"t",
"commands":[{"command_id":"c-9","requested_at_ms":1,"kind":"future_command"}]}"#;
let ack: AgentStatusAck = serde_json::from_str(json).expect("decode");
assert_eq!(ack.commands[0].kind, "future_command");
}
#[test]
fn an_agent_status_report_can_carry_command_results() {
let legacy = r#"{"agent_id":"a","instance_id":"i","version":"0.9.0"}"#;
let report: AgentStatusReport = serde_json::from_str(legacy).expect("decode");
assert!(report.command_acks.is_empty());
let json = r#"{"agent_id":"a","instance_id":"i","version":"0.9.11",
"command_acks":[{"command_id":"c-1","outcome":"succeeded",
"detail":"probes=6 failed=0"}]}"#;
let report: AgentStatusReport = serde_json::from_str(json).expect("decode");
assert_eq!(
report.command_acks,
vec![AgentCommandAck {
command_id: "c-1".to_string(),
outcome: command_outcome::SUCCEEDED.to_string(),
detail: "probes=6 failed=0".to_string(),
}]
);
}
}