add headless automation
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good

This commit is contained in:
2026-09-22 13:28:31 +01:00
parent 5b106af0f3
commit e0c08c8b00
15 changed files with 883 additions and 47 deletions
@@ -579,6 +579,8 @@ mod tests {
assert_eq!(firmware.os.sessions().vm_session_count(), 0);
assert_eq!(firmware.os.vm().current_cartridge_title(), "");
assert_eq!(firmware.os.lifecycle().resident_game(), None);
assert_eq!(firmware.os.lifecycle().foreground_owner(), ForegroundOwner::Hub);
}
#[test]
@@ -9,6 +9,10 @@ pub struct ResetStep;
impl ResetStep {
pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
ctx.os.log(LogLevel::Info, LogSource::Pos, 0, "Firmware Reset".to_string());
// Reset is a cold-boot boundary. Clearing only the VM session leaves
// the lifecycle registry pointing at the old resident game, which
// rejects the next cartridge as a second resident game.
let _ = ctx.os.lifecycle().terminate_resident_game();
ctx.os.sessions().clear_vm_sessions();
ctx.os.vm().reset_global_runtime_state();
}
@@ -0,0 +1,14 @@
[package]
name = "prometeu-host-headless"
version = "0.1.0"
edition = "2024"
license.workspace = true
repository.workspace = true
description = "In-process Prometeu host that boots and steps cartridges without a window, display, or audio device."
[dependencies]
prometeu-bytecode = { path = "../../console/prometeu-bytecode" }
prometeu-drivers = { path = "../../console/prometeu-drivers" }
prometeu-firmware = { path = "../../console/prometeu-firmware" }
prometeu-hal = { path = "../../console/prometeu-hal" }
prometeu-system = { path = "../../console/prometeu-system" }
@@ -0,0 +1,333 @@
use std::fmt;
use std::sync::Arc;
use prometeu_bytecode::Value;
use prometeu_drivers::hardware::Hardware;
use prometeu_drivers::{LocalFramebufferRenderBackend, MemoryBanks};
use prometeu_firmware::firmware_state::{AppCrashesStep, ResetStep};
use prometeu_firmware::{BootTarget, Firmware, FirmwareState};
use prometeu_hal::{
AssetBridge, AudioBridge, FrameId, Game2DFrameComposer, InputPlatform, InputSignals,
OwnedRgba8888Frame, RenderBackend, RenderSubmission, RenderSubmissionSink, RenderSubmitError,
RenderWorkerError, RuntimePlatform, TelemetryPlatform,
};
use prometeu_system::{CrashReport, LatestRenderFrameStore, RenderWorkerConfig};
const BOOT_TICK_LIMIT: usize = 64;
const LOGICAL_FRAME_TICK_LIMIT: usize = 100_000;
const FRAME_PUBLISH_SPINS: usize = 10_000;
/// One published logical frame plus the automation counter.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CapturedFrame {
pub logical_frame_index: u64,
pub frame: OwnedRgba8888Frame,
}
/// Debugger-shaped execution snapshot.
#[derive(Debug, Clone)]
pub struct HostState {
pub pc: usize,
pub stack_top: Vec<Value>,
pub frame_index: u64,
pub app_id: u32,
}
#[derive(Debug)]
pub enum HostError {
BootFailed(String),
LogicalFrameDidNotClose,
FrameNotPublished,
RenderWorker(RenderWorkerError),
}
impl fmt::Display for HostError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::BootFailed(reason) => write!(f, "boot failed: {reason}"),
Self::LogicalFrameDidNotClose => {
write!(f, "logical frame did not reach FrameSync, end of ROM, or a fault")
}
Self::FrameNotPublished => write!(f, "logical frame closed without a published frame"),
Self::RenderWorker(error) => write!(f, "render worker failed: {error:?}"),
}
}
}
impl std::error::Error for HostError {}
/// In-process host. The desktop winit runner is a separate crate and is not linked here.
pub struct HeadlessHost {
firmware: Firmware,
platform: HeadlessPlatform,
signals: InputSignals,
/// Frame id observed before the logical frame that `capture_frame` should return.
previous_frame_id: Option<FrameId>,
}
struct HeadlessPlatform {
hardware: Hardware,
store: LatestRenderFrameStore,
}
impl HeadlessHost {
pub fn new() -> Self {
let memory_banks = Arc::new(MemoryBanks::new());
let hardware = Hardware::new_with_memory_banks(Arc::clone(&memory_banks));
let store = LatestRenderFrameStore::default();
Self {
firmware: Firmware::new(None),
platform: HeadlessPlatform { hardware, store },
signals: InputSignals::default(),
previous_frame_id: None,
}
}
/// Load `path` and tick until the firmware is in `GameRunning`.
///
/// The transition into `GameRunning` is the last tick. The first game
/// logical frame stays available for [`Self::advance_frame`].
pub fn boot(&mut self, path: impl Into<String>) -> Result<(), HostError> {
let path = path.into();
self.firmware.boot_target = BootTarget::Cartridge { path, debug: false, debug_port: 7777 };
self.ensure_worker()?;
if matches!(self.firmware.state, FirmwareState::GameRunning(_)) {
return Ok(());
}
for _ in 0..BOOT_TICK_LIMIT {
if matches!(self.firmware.state, FirmwareState::GameRunning(_)) {
return Ok(());
}
if matches!(self.firmware.state, FirmwareState::AppCrashes(_)) {
let detail = self
.get_fault()
.map(|report| report.summary())
.unwrap_or_else(|| "cartridge crashed during boot".to_string());
return Err(HostError::BootFailed(detail));
}
if matches!(self.firmware.state, FirmwareState::HubHome(_)) {
return Err(HostError::BootFailed("cartridge did not load".to_string()));
}
self.tick_once();
}
if matches!(self.firmware.state, FirmwareState::GameRunning(_)) {
Ok(())
} else {
Err(HostError::BootFailed("boot did not reach the game".to_string()))
}
}
pub fn reset(&mut self) {
self.signals = InputSignals::default();
self.firmware.change_state(
FirmwareState::Reset(ResetStep),
&self.signals,
&mut self.platform,
);
self.previous_frame_id = self.platform.store.latest_frame().map(|frame| frame.frame_id);
}
pub fn pause(&mut self) {
self.firmware.os.vm().set_paused(true);
}
pub fn resume(&mut self) {
self.firmware.os.vm().set_paused(false);
}
/// Execute one VM instruction. This does not close a logical frame.
pub fn step(&mut self) -> Option<CrashReport> {
self.firmware.os.vm().set_paused(true);
let report = self.firmware.os.vm().debug_step_active_session(&mut self.platform);
self.platform.hardware.audio.clear_commands();
report
}
pub fn advance_frame(&mut self) -> Result<(), HostError> {
let start = self.firmware.os.vm().logical_frame_index();
self.previous_frame_id = self.platform.store.latest_frame().map(|frame| frame.frame_id);
self.firmware.os.vm().set_paused(false);
self.firmware.os.vm().request_debug_step();
for _ in 0..LOGICAL_FRAME_TICK_LIMIT {
self.tick_once();
if self.fault_is_visible() {
self.firmware.os.vm().set_paused(true);
return Ok(());
}
if self.firmware.os.vm().logical_frame_index() > start {
self.firmware.os.vm().set_paused(true);
return Ok(());
}
}
Err(HostError::LogicalFrameDidNotClose)
}
pub fn advance_frames(&mut self, count: u64) -> Result<(), HostError> {
for _ in 0..count {
self.advance_frame()?;
}
Ok(())
}
pub fn set_input(&mut self, signals: InputSignals) {
self.signals = signals;
}
pub fn clear_input(&mut self) {
self.signals = InputSignals::default();
}
pub fn set_right(&mut self, down: bool) {
self.signals.right_signal = down;
}
pub fn capture_frame(&mut self) -> Result<CapturedFrame, HostError> {
let frame = self.wait_for_published_frame(self.previous_frame_id)?;
Ok(CapturedFrame {
logical_frame_index: self.firmware.os.vm().logical_frame_index(),
frame,
})
}
pub fn get_state(&mut self) -> HostState {
HostState {
pc: self.firmware.os.vm().active_pc().unwrap_or(0),
stack_top: self.firmware.os.vm().active_operand_stack_top(10),
frame_index: self.firmware.os.vm().logical_frame_index(),
app_id: self.firmware.os.vm().current_app_id(),
}
}
pub fn get_fault(&mut self) -> Option<CrashReport> {
if let Some(report) = self.firmware.os.vm().last_crash_report() {
return Some(report.clone());
}
match &self.firmware.state {
FirmwareState::AppCrashes(AppCrashesStep { report }) => Some(report.clone()),
_ => None,
}
}
fn tick_once(&mut self) {
self.firmware.tick(&self.signals, &mut self.platform);
self.platform.hardware.audio.clear_commands();
}
fn fault_is_visible(&mut self) -> bool {
self.firmware.os.vm().last_crash_report().is_some()
|| matches!(self.firmware.state, FirmwareState::AppCrashes(_))
}
fn ensure_worker(&mut self) -> Result<(), HostError> {
if self.firmware.os.vm().render_worker_controller().is_some() {
return Ok(());
}
let backend = LocalFramebufferRenderBackend::new_with_memory_banks(
Hardware::W,
Hardware::H,
Arc::clone(&self.platform.hardware.memory_banks),
self.platform.hardware.assets.glyph_asset_slot_index(),
);
let store = self.platform.store.clone();
self.firmware.os.vm().start_render_worker(RenderWorkerConfig::default(), backend, store);
Ok(())
}
fn wait_for_published_frame(
&mut self,
previous: Option<FrameId>,
) -> Result<OwnedRgba8888Frame, HostError> {
for _ in 0..FRAME_PUBLISH_SPINS {
if let Some(error) = self
.firmware
.os
.vm()
.render_worker_controller()
.and_then(|worker| worker.last_error())
{
return Err(HostError::RenderWorker(error));
}
if let Some(frame) = self.platform.store.latest_frame()
&& Some(frame.frame_id) != previous
{
return Ok(frame);
}
std::hint::spin_loop();
}
Err(HostError::FrameNotPublished)
}
}
impl Default for HeadlessHost {
fn default() -> Self {
Self::new()
}
}
impl RenderSubmissionSink for HeadlessPlatform {
fn submit_render_submission(
&mut self,
submission: RenderSubmission,
) -> Result<(), RenderSubmitError> {
let frame_id = submission.frame_id;
let ownership = submission.ownership;
self.hardware.submit_render_submission(submission)?;
let (width, height) = self.hardware.gfx.size();
let pixels = self.hardware.gfx.front_buffer().to_vec();
let frame = OwnedRgba8888Frame::packed(frame_id, ownership, width, height, pixels)
.map_err(|_| RenderSubmitError::SubmissionRejected)?;
self.store.publish_frame(frame);
Ok(())
}
}
impl RuntimePlatform for HeadlessPlatform {
fn display_size(&self) -> (usize, usize) {
(Hardware::W, Hardware::H)
}
fn render_submission_sink(&mut self) -> &mut dyn RenderSubmissionSink {
self
}
fn render_backend(&mut self) -> &mut dyn RenderBackend {
&mut self.hardware
}
fn game2d_frame_composer(&mut self) -> &mut dyn Game2DFrameComposer {
&mut self.hardware
}
fn audio(&self) -> &dyn AudioBridge {
self.hardware.audio()
}
fn audio_mut(&mut self) -> &mut dyn AudioBridge {
self.hardware.audio_mut()
}
fn input(&self) -> &dyn InputPlatform {
self.hardware.input()
}
fn input_mut(&mut self) -> &mut dyn InputPlatform {
self.hardware.input_mut()
}
fn assets(&self) -> &dyn AssetBridge {
self.hardware.assets()
}
fn assets_mut(&mut self) -> &mut dyn AssetBridge {
self.hardware.assets_mut()
}
fn telemetry(&self) -> &dyn TelemetryPlatform {
self.hardware.telemetry()
}
}
@@ -0,0 +1,11 @@
//! Headless Prometeu host.
//!
//! This crate boots a directory cartridge and steps logical frames in process.
//! It does not open a window, a display surface, or an audio device.
//!
//! The desktop host's `stepFrame` command still advances on the 60 Hz winit loop.
//! That pacing stays in `prometeu-host-desktop-winit` until a later protocol agenda.
mod host;
pub use host::{CapturedFrame, HeadlessHost, HostError, HostState};
@@ -0,0 +1,260 @@
use std::fs;
use std::path::Path;
use std::time::{Duration, Instant};
use prometeu_bytecode::assembler::assemble;
use prometeu_bytecode::model::{BytecodeModule, DebugInfo, Export, FunctionMeta, SyscallDecl};
use prometeu_hal::color::Color;
use prometeu_host_headless::{CapturedFrame, HeadlessHost, HostState};
use prometeu_system::CrashReport;
const RED: u32 = Color::RED.raw();
const BLUE: u32 = Color::BLUE.raw();
#[test]
fn step_does_not_complete_a_logical_frame() {
let mut host = boot_color();
let before = host.get_state().frame_index;
host.step();
assert_eq!(host.get_state().frame_index, before);
}
#[test]
fn clear_input_drops_right() {
let mut host = boot_color();
host.set_right(true);
host.clear_input();
host.advance_frame().expect("frame");
assert_color(&host.capture_frame().expect("frame"), BLUE);
}
#[test]
fn right_hold_then_release_changes_pixels() {
let mut host = boot_color();
let before = host.get_state().frame_index;
host.set_right(true);
host.advance_frames(60).expect("hold");
let held = host.capture_frame().expect("held frame");
assert_eq!(host.get_state().frame_index, before + 60);
assert_color(&held, RED);
assert!(host.get_fault().is_none());
host.set_right(false);
host.advance_frames(1).expect("release");
let released = host.capture_frame().expect("released frame");
assert_eq!(released.logical_frame_index, before + 61);
assert_color(&released, BLUE);
assert!(host.get_fault().is_none());
}
#[test]
fn two_runs_match_oracle() {
let first = run_color_sequence();
let second = run_color_sequence();
assert_eq!(first.held.logical_frame_index, second.held.logical_frame_index);
assert_eq!(first.held.frame.pixels, second.held.frame.pixels);
assert_eq!(first.held.frame.frame_id, second.held.frame.frame_id);
assert_eq!(first.released.frame.pixels, second.released.frame.pixels);
assert_eq!(first.released.frame.frame_id, second.released.frame.frame_id);
assert_eq!(first.released.logical_frame_index, second.released.logical_frame_index);
assert_same_state(&first.state, &second.state);
assert_eq!(first.fault, second.fault);
}
#[test]
fn reset_matches_fresh_host() {
let mut host = boot_color();
let _ = run_on(&mut host);
host.reset();
host.boot(color_cartridge()).expect("reboot");
let after_reset = run_on(&mut host);
let fresh = run_color_sequence();
assert_eq!(after_reset.held.frame.pixels, fresh.held.frame.pixels);
assert_eq!(after_reset.released.frame.pixels, fresh.released.frame.pixels);
assert_eq!(after_reset.held.frame.frame_id, fresh.held.frame.frame_id);
assert_eq!(after_reset.released.frame.frame_id, fresh.released.frame.frame_id);
assert_eq!(after_reset.released.logical_frame_index, fresh.released.logical_frame_index);
assert_same_state(&after_reset.state, &fresh.state);
assert_eq!(after_reset.fault, fresh.fault);
}
#[test]
fn trap_is_structured() {
let dir = temp_cart("fault");
write_cartridge(&dir, 42, "Fault", &fault_program(), &[]);
let mut host = HeadlessHost::new();
host.boot(&dir).expect("boot fault cartridge");
host.advance_frame().expect("faulting frame");
match host.get_fault() {
Some(report @ CrashReport::VmTrap { .. }) => {
assert!(report.pc().is_some());
}
other => panic!("expected VmTrap, got {other:?}"),
}
}
#[test]
fn three_hundred_frames_finish_without_refresh_sleep() {
let mut host = boot_color();
let started = Instant::now();
host.advance_frames(300).expect("fast frames");
assert!(started.elapsed() < Duration::from_secs(2));
}
#[test]
fn audio_play_does_not_need_a_device() {
let mut host = boot_color();
host.advance_frame().expect("frame with audio.play");
assert!(host.get_fault().is_none());
assert_color(&host.capture_frame().expect("frame"), BLUE);
}
struct ColorOracle {
held: CapturedFrame,
released: CapturedFrame,
state: HostState,
fault: Option<CrashReport>,
}
fn boot_color() -> HeadlessHost {
let mut host = HeadlessHost::new();
host.boot(color_cartridge()).expect("boot color cartridge");
host
}
fn color_cartridge() -> String {
let dir = temp_cart("color");
write_cartridge(&dir, 41, "Right Pixel", &color_program(), &color_syscalls());
dir
}
fn run_color_sequence() -> ColorOracle {
let mut host = boot_color();
run_on(&mut host)
}
fn run_on(host: &mut HeadlessHost) -> ColorOracle {
host.set_right(true);
host.advance_frames(60).expect("hold");
let held = host.capture_frame().expect("held");
host.set_right(false);
host.advance_frames(1).expect("release");
let released = host.capture_frame().expect("released");
let state = host.get_state();
let fault = host.get_fault();
ColorOracle { held, released, state, fault }
}
fn assert_color(captured: &CapturedFrame, color: u32) {
assert_eq!(captured.frame.width, 480);
assert_eq!(captured.frame.height, 270);
assert!(captured.frame.pixels.iter().all(|pixel| *pixel == color));
}
fn assert_same_state(left: &HostState, right: &HostState) {
assert_eq!(left.pc, right.pc);
assert_eq!(left.frame_index, right.frame_index);
assert_eq!(left.app_id, right.app_id);
assert_eq!(format!("{:?}", left.stack_top), format!("{:?}", right.stack_top));
}
fn temp_cart(name: &str) -> String {
let dir = std::env::temp_dir().join(format!(
"prometeu-headless-{name}-{}-{}",
std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
));
fs::create_dir_all(&dir).expect("temp cartridge dir");
dir.to_string_lossy().into_owned()
}
fn write_cartridge(dir: &str, app_id: u32, title: &str, program: &[u8], syscalls: &[SyscallDecl]) {
let path = Path::new(dir);
fs::write(path.join("program.pbx"), program).expect("program");
fs::write(
path.join("manifest.json"),
format!(
"{{\n \"magic\": \"PMTU\",\n \"cartridge_version\": 1,\n \"app_id\": {app_id},\n \"title\": \"{title}\",\n \"app_version\": \"0.1.0\",\n \"app_mode\": \"Game\",\n \"capabilities\": [\"gfx2d\", \"audio\"]\n}}\n"
),
)
.expect("manifest");
let _ = syscalls;
}
fn color_program() -> Vec<u8> {
let mut rom = Vec::new();
rom.extend(asm("PUSH_I32 0\n\
PUSH_I32 0\n\
PUSH_I32 0\n\
PUSH_I32 255\n\
PUSH_I32 128\n\
PUSH_I32 1\n\
PUSH_I32 0\n\
HOSTCALL 1\n\
POP_N 1\n\
INTRINSIC 0x2000\n\
INTRINSIC 0x2013\n\
INTRINSIC 0x2032\n"));
let jump_to_blue = rom.len() + 2;
rom.extend(asm("JMP_IF_FALSE 0"));
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
let blue_at = rom.len() as u32;
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
rom[jump_to_blue..jump_to_blue + 4].copy_from_slice(&blue_at.to_le_bytes());
module(rom, color_syscalls())
}
fn fault_program() -> Vec<u8> {
// `INTRINSIC 0xDEADBEEF` is rejected by the loader as `VerificationFailed`.
// `TRAP` is a legal instruction that becomes `CrashReport::VmTrap` at runtime.
module(asm("TRAP\nFRAME_SYNC\nRET\n"), vec![])
}
fn color_syscalls() -> Vec<SyscallDecl> {
vec![
SyscallDecl {
module: "gfx2d".into(),
name: "clear".into(),
version: 1,
arg_slots: 1,
ret_slots: 0,
},
SyscallDecl {
module: "audio".into(),
name: "play".into(),
version: 1,
arg_slots: 7,
ret_slots: 1,
},
]
}
fn module(code: Vec<u8>, syscalls: Vec<SyscallDecl>) -> Vec<u8> {
BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![FunctionMeta {
code_offset: 0,
code_len: code.len() as u32,
param_slots: 0,
local_slots: 0,
return_slots: 0,
max_stack_slots: 8,
}],
code,
debug_info: Some(DebugInfo {
pc_to_span: vec![],
function_names: vec![(0, "main".into())],
}),
exports: vec![Export { symbol: "main".into(), func_idx: 0 }],
syscalls,
}
.serialize()
}
fn asm(source: &str) -> Vec<u8> {
assemble(source).expect("assemble")
}