use base64::{Engine as _, engine::general_purpose::STANDARD}; use prometeu_bytecode::Value as VmValue; use prometeu_hal::InputSignals; use prometeu_system::CrashReport; use prometeu_vm::VmInitError; use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use std::io; use crate::{CapturedFrame, HostError, HostExecutionStatus, HostState}; pub const CAPABILITIES: &[&str] = &[ "boot", "reset", "set_input", "clear_input", "advance", "capture", "get_state", "get_fault", "cancel", "shutdown", ]; #[derive(Clone, Debug, Serialize)] #[serde(rename_all = "camelCase")] pub struct Limits { pub max_frames: u64, pub max_command_bytes: usize, pub max_response_bytes: usize, pub handshake_timeout_ms: u64, pub call_timeout_ms: u64, pub shutdown_timeout_ms: u64, } impl Default for Limits { fn default() -> Self { Self { max_frames: 600, max_command_bytes: 64 * 1024, max_response_bytes: 32 * 1024 * 1024, handshake_timeout_ms: 5_000, call_timeout_ms: 60_000, shutdown_timeout_ms: 5_000, } } } impl Limits { pub fn validate(&self) -> io::Result<()> { if self.max_frames == 0 || self.max_command_bytes < 4096 || self.max_response_bytes < 4096 || self.handshake_timeout_ms == 0 || self.call_timeout_ms == 0 || self.shutdown_timeout_ms == 0 { return Err(io::Error::new( io::ErrorKind::InvalidInput, "limits must be positive and message bounds at least 4096 bytes", )); } Ok(()) } } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields, rename_all = "camelCase")] pub(super) struct Request { pub request_id: String, pub command: String, pub params: Value, } pub(super) fn valid_id(id: &str) -> bool { !id.is_empty() && id.len() <= 128 } #[derive(Debug, Deserialize, Serialize)] #[serde(deny_unknown_fields)] pub(super) struct Version { pub major: u32, pub minor: u32, } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields, rename_all = "camelCase")] pub(super) struct Initialize { pub protocol_version: Version, pub required_capabilities: Vec, } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields)] pub(super) struct Boot { pub path: String, } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields)] pub(super) struct Advance { pub frames: u64, } #[derive(Debug, Deserialize)] #[serde(deny_unknown_fields, rename_all = "camelCase")] pub(super) struct Cancel { pub target_request_id: String, } #[derive(Debug, Default, Deserialize)] #[serde(default, deny_unknown_fields, rename_all = "camelCase")] pub(super) struct Input { up: bool, down: bool, left: bool, right: bool, a: bool, b: bool, x: bool, y: bool, l: bool, r: bool, start: bool, select: bool, touch: bool, touch_x: i32, touch_y: i32, } impl From for InputSignals { fn from(s: Input) -> Self { Self { up_signal: s.up, down_signal: s.down, left_signal: s.left, right_signal: s.right, a_signal: s.a, b_signal: s.b, x_signal: s.x, y_signal: s.y, l_signal: s.l, r_signal: s.r, start_signal: s.start, select_signal: s.select, f_signal: s.touch, x_pos: s.touch_x, y_pos: s.touch_y, } } } #[derive(Debug)] pub(super) enum Command { Initialize(Initialize), Boot(Boot), Reset, SetInput(Input), ClearInput, Advance(Advance), Capture, GetState, GetFault, Cancel(Cancel), Shutdown, } fn params(value: Value) -> Result { serde_json::from_value(value).map_err(|e| WireError::new("invalid_params", e.to_string())) } fn empty(value: &Value) -> Result<(), WireError> { if value.as_object().is_some_and(|v| v.is_empty()) { Ok(()) } else { Err(WireError::new("invalid_params", "expected an empty params object")) } } pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> { if !valid_id(&req.request_id) { return Err(WireError::new("invalid_request", "requestId must contain 1..128 UTF-8 bytes")); } let command = match req.command.as_str() { "initialize" => Command::Initialize(params(req.params)?), "boot" => { let p: Boot = params(req.params)?; if p.path.trim().is_empty() { return Err(WireError::new("invalid_params", "path is empty")); } Command::Boot(p) } "advance" => Command::Advance(params(req.params)?), "set_input" => Command::SetInput(params(req.params)?), "cancel" => { let p: Cancel = params(req.params)?; if !valid_id(&p.target_request_id) { return Err(WireError::new("invalid_params", "invalid targetRequestId")); } Command::Cancel(p) } "reset" | "clear_input" | "capture" | "get_state" | "get_fault" | "shutdown" => { empty(&req.params)?; match req.command.as_str() { "reset" => Command::Reset, "clear_input" => Command::ClearInput, "capture" => Command::Capture, "get_state" => Command::GetState, "get_fault" => Command::GetFault, _ => Command::Shutdown, } } _ => return Err(WireError::new("unknown_command", "unknown command")), }; Ok((req.request_id, command)) } #[derive(Debug, Serialize)] pub(super) struct WireError { pub code: &'static str, pub message: String, pub details: Value, } impl WireError { pub fn new(code: &'static str, message: impl Into) -> Self { Self { code, message: message.into(), details: json!({}) } } } pub(super) fn host_error(error: HostError) -> WireError { let (code, details) = match &error { HostError::AlreadyBooted => ("already_booted", json!({})), HostError::BootFailed { reason, report } => { ("boot_failed", json!({"reason":reason,"fault":report.as_ref().map(fault)})) } HostError::InvalidState { operation, status } => { ("invalid_state", json!({"operation":operation,"status":status_name(*status)})) } HostError::FrameAdvanceWatchdogExpired { host_tick_limit } => { ("watchdog_expired", json!({"hostTickLimit":host_tick_limit})) } HostError::FrameNotPublished { previous } => { ("frame_not_published", json!({"previousFrameId":previous.map(|id| id.get())})) } HostError::NoFrameAvailable => ("no_frame_available", json!({})), }; WireError { code, message: error.to_string(), details } } fn status_name(status: HostExecutionStatus) -> &'static str { match status { HostExecutionStatus::Running => "running", HostExecutionStatus::Paused => "paused", HostExecutionStatus::Terminated => "terminated", HostExecutionStatus::Faulted => "faulted", } } fn stack_value(value: &VmValue) -> Value { match value { VmValue::Int32(v) => json!({"kind":"int32","value":v}), VmValue::Int64(v) => json!({"kind":"int64","value":v.to_string()}), VmValue::Float(v) => json!({"kind":"float64","value":v.to_string()}), VmValue::Boolean(v) => json!({"kind":"boolean","value":v}), VmValue::String(v) => json!({"kind":"string","value":v.as_ref()}), VmValue::HeapRef(v) => json!({"kind":"heap_ref","value":v.0}), VmValue::Null => json!({"kind":"null","value":null}), } } pub(super) fn state(s: HostState) -> Value { json!({"pc":s.pc,"stackTop":s.stack_top.iter().map(stack_value).collect::>(), "logicalFrameIndex":s.frame_index,"tickIndex":s.tick_index,"appId":s.app_id, "status":status_name(s.status)}) } pub(super) fn fault(report: &CrashReport) -> Value { let mut result = json!({"kind":report.kind(),"pc":report.pc(),"summary":report.summary()}); match report { CrashReport::VmTrap { trap } => { result["trap"] = json!({"code":trap.code,"opcode":trap.opcode, "message":trap.message,"pc":trap.pc,"span":trap.span}); } CrashReport::VmPanic { message, .. } => { result["message"] = json!(message); } CrashReport::VmInit { error } => { let code = match error { VmInitError::InvalidFormat => "invalid_format", VmInitError::UnsupportedFormat => "unsupported_format", VmInitError::ImageLoadFailed(_) => "image_load_failed", VmInitError::LoaderPatchFailed(_) => "loader_patch_failed", VmInitError::EntrypointNotFound => "entrypoint_not_found", VmInitError::VerificationFailed(_) => "verification_failed", }; result["initError"] = json!({"code":code,"message":format!("{error:?}")}); } } result } pub(super) fn capture(c: CapturedFrame) -> Result { let frame = c.frame; let width = u32::try_from(frame.width) .map_err(|_| WireError::new("capture_failed", "width exceeds PNG limit"))?; let height = u32::try_from(frame.height) .map_err(|_| WireError::new("capture_failed", "height exceeds PNG limit"))?; let mut rgba = Vec::new(); for y in 0..frame.height { for pixel in frame.row(y).ok_or_else(|| WireError::new("capture_failed", "invalid row"))? { rgba.extend_from_slice(&pixel.to_be_bytes()); } } let mut bytes = Vec::new(); { let mut encoder = png::Encoder::new(&mut bytes, width, height); encoder.set_color(png::ColorType::Rgba); encoder.set_depth(png::BitDepth::Eight); let mut writer = encoder.write_header().map_err(|e| WireError::new("capture_failed", e.to_string()))?; writer .write_image_data(&rgba) .map_err(|e| WireError::new("capture_failed", e.to_string()))?; writer.finish().map_err(|e| WireError::new("capture_failed", e.to_string()))?; } Ok(json!({"mimeType":"image/png","encoding":"base64","data":STANDARD.encode(bytes), "width":width,"height":height,"stridePixels":frame.stride_pixels,"pixelFormat":"RGBA8888", "logicalFrameIndex":c.logical_frame_index,"frameId":frame.frame_id.get()})) }