use std::path::Path;
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use crate::integrations::rx::resolve_cmd;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkflowDef {
pub name: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub agent: String,
pub steps: Vec<WorkflowStep>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkflowStep {
pub id: String,
pub run: String,
#[serde(default)]
pub depends_on: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_success: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_failure: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum StepState {
Pending,
Running,
Done,
Failed,
Skipped,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkflowState {
pub workflow: String,
#[serde(default)]
pub definition_hash: String,
pub steps: Vec<StepStatus>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StepStatus {
pub id: String,
pub state: StepState,
#[serde(skip_serializing_if = "Option::is_none")]
pub exit_code: Option<i32>,
}
pub fn load(path: &Path) -> Result<WorkflowDef> {
let raw = std::fs::read_to_string(path)
.with_context(|| format!("reading workflow file {}", path.display()))?;
serde_yaml::from_str(&raw).with_context(|| format!("parsing workflow YAML {}", path.display()))
}
pub fn runnable_steps<'a>(def: &'a WorkflowDef, state: &WorkflowState) -> Vec<&'a WorkflowStep> {
def.steps
.iter()
.filter(|step| {
let status = state.steps.iter().find(|s| s.id == step.id);
let is_pending = status
.map(|s| s.state == StepState::Pending)
.unwrap_or(true);
if !is_pending {
return false;
}
step.depends_on.iter().all(|dep_id| {
state
.steps
.iter()
.find(|s| s.id == *dep_id)
.map(|s| s.state == StepState::Done)
.unwrap_or(false)
})
})
.collect()
}
pub fn run(def: &WorkflowDef, root: &Path) -> Result<WorkflowState> {
let state_path = root
.join(".ctx")
.join("godmode")
.join(format!("workflow-{}.json", def.name));
let mut state = load_or_init_state(def, &state_path)?;
persist_state(&state, &state_path)?;
loop {
let runnable: Vec<String> = runnable_steps(def, &state)
.into_iter()
.map(|s| s.id.clone())
.collect();
if runnable.is_empty() {
break;
}
for step_id in runnable {
let step = def.steps.iter().find(|s| s.id == step_id).unwrap();
set_state(&mut state, &step_id, StepState::Running, None);
persist_state(&state, &state_path)?;
let (prog, args) = resolve_cmd(&step.run);
let exit_status = std::process::Command::new(&prog)
.args(&args)
.status()
.with_context(|| format!("failed to launch step '{}': {}", step_id, step.run))?;
let code = exit_status.code().unwrap_or(-1);
if exit_status.success() {
set_state(&mut state, &step_id, StepState::Done, Some(code));
if let Some(ref target) = step.on_success.clone() {
skip_all_except(&mut state, def, target);
}
} else {
set_state(&mut state, &step_id, StepState::Failed, Some(code));
if let Some(ref target) = step.on_failure.clone() {
skip_all_except(&mut state, def, target);
} else {
persist_state(&state, &state_path)?;
return Ok(state);
}
}
persist_state(&state, &state_path)?;
}
}
Ok(state)
}
fn load_or_init_state(def: &WorkflowDef, path: &Path) -> Result<WorkflowState> {
if !path.exists() {
return Ok(init_state(def));
}
let raw = std::fs::read_to_string(path)
.with_context(|| format!("reading workflow state {}", path.display()))?;
let mut state: WorkflowState = serde_json::from_str(&raw)
.with_context(|| format!("parsing workflow state {}", path.display()))?;
let current_hash = definition_hash(def);
let compatible_steps = state.steps.len() == def.steps.len()
&& def
.steps
.iter()
.zip(&state.steps)
.all(|(step, status)| step.id == status.id);
if state.workflow != def.name
|| !compatible_steps
|| (!state.definition_hash.is_empty() && state.definition_hash != current_hash)
{
anyhow::bail!("workflow definition drift detected for {}", def.name);
}
state.definition_hash = current_hash;
for step in &mut state.steps {
if step.state == StepState::Running {
step.state = StepState::Pending;
step.exit_code = None;
}
}
Ok(state)
}
fn init_state(def: &WorkflowDef) -> WorkflowState {
WorkflowState {
workflow: def.name.clone(),
definition_hash: definition_hash(def),
steps: def
.steps
.iter()
.map(|s| StepStatus {
id: s.id.clone(),
state: StepState::Pending,
exit_code: None,
})
.collect(),
}
}
fn definition_hash(def: &WorkflowDef) -> String {
let bytes = serde_json::to_vec(&def.steps).expect("workflow steps must serialize");
let hash = bytes.iter().fold(0xcbf29ce484222325_u64, |hash, byte| {
(hash ^ u64::from(*byte)).wrapping_mul(0x100000001b3)
});
format!("{hash:016x}")
}
fn set_state(state: &mut WorkflowState, id: &str, new_state: StepState, code: Option<i32>) {
if let Some(s) = state.steps.iter_mut().find(|s| s.id == id) {
s.state = new_state;
s.exit_code = code;
}
}
fn skip_all_except(state: &mut WorkflowState, def: &WorkflowDef, keep_id: &str) {
for s in state.steps.iter_mut() {
if s.state == StepState::Pending {
s.state = StepState::Skipped;
}
}
let reachable = reachable_from(def, keep_id);
for s in state.steps.iter_mut() {
if reachable.contains(&s.id) && s.state == StepState::Skipped {
s.state = StepState::Pending;
}
}
}
fn reachable_from(def: &WorkflowDef, start: &str) -> Vec<String> {
let mut visited: Vec<String> = vec![start.to_string()];
let mut queue: Vec<String> = vec![start.to_string()];
while !queue.is_empty() {
let cur = queue.remove(0);
for step in &def.steps {
if step.depends_on.iter().any(|d| d == &cur) && !visited.contains(&step.id) {
visited.push(step.id.clone());
queue.push(step.id.clone());
}
}
}
visited
}
fn persist_state(state: &WorkflowState, path: &Path) -> Result<()> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)
.with_context(|| format!("creating workflow state directory {}", parent.display()))?;
}
let json = serde_json::to_string_pretty(state).context("serializing workflow state")?;
std::fs::write(path, json).with_context(|| format!("writing workflow state {}", path.display()))
}
#[cfg(test)]
mod tests {
use super::*;
fn make_step(id: &str, run: &str, deps: Vec<&str>) -> WorkflowStep {
WorkflowStep {
id: id.to_string(),
run: run.to_string(),
depends_on: deps.into_iter().map(str::to_string).collect(),
on_success: None,
on_failure: None,
}
}
fn two_step_def() -> WorkflowDef {
WorkflowDef {
name: "test-wf".to_string(),
description: "a test workflow".to_string(),
agent: "test-agent".to_string(),
steps: vec![
make_step("step1", "true", vec![]),
make_step("step2", "true", vec!["step1"]),
],
}
}
#[test]
fn load_parses_yaml() {
let tmp = std::env::temp_dir().join("godmode-workflow-test-load.yaml");
std::fs::write(
&tmp,
"name: ci\ndescription: CI\nagent: tdd\nsteps:\n - id: build\n run: cargo build\n - id: test\n run: cargo test\n depends_on: [build]\n",
)
.unwrap();
let def = load(&tmp).unwrap();
let _ = std::fs::remove_file(&tmp);
assert_eq!(def.name, "ci");
assert_eq!(def.steps.len(), 2);
assert_eq!(def.steps[1].depends_on, vec!["build"]);
}
#[test]
fn runnable_steps_returns_root_steps_initially() {
let def = two_step_def();
let state = init_state(&def);
let runnable = runnable_steps(&def, &state);
assert_eq!(runnable.len(), 1);
assert_eq!(runnable[0].id, "step1");
}
#[test]
fn runnable_steps_unlocks_after_dep_done() {
let def = two_step_def();
let mut state = init_state(&def);
set_state(&mut state, "step1", StepState::Done, Some(0));
let runnable = runnable_steps(&def, &state);
assert_eq!(runnable.len(), 1);
assert_eq!(runnable[0].id, "step2");
}
#[test]
fn runnable_steps_empty_when_all_done() {
let def = two_step_def();
let mut state = init_state(&def);
set_state(&mut state, "step1", StepState::Done, Some(0));
set_state(&mut state, "step2", StepState::Done, Some(0));
assert!(runnable_steps(&def, &state).is_empty());
}
#[test]
fn run_executes_two_step_workflow() {
let dir = std::env::temp_dir().join("godmode-workflow-run-test");
std::fs::create_dir_all(dir.join(".ctx").join("godmode")).unwrap();
let def = two_step_def();
let final_state = run(&def, &dir).unwrap();
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(final_state.workflow, "test-wf");
assert!(final_state.steps.iter().all(|s| s.state == StepState::Done));
}
#[test]
fn run_marks_failed_on_non_zero_exit() {
let dir = std::env::temp_dir().join("godmode-workflow-fail-test");
std::fs::create_dir_all(dir.join(".ctx").join("godmode")).unwrap();
let def = WorkflowDef {
name: "fail-wf".to_string(),
description: String::new(),
agent: String::new(),
steps: vec![make_step("bad", "false", vec![])],
};
let final_state = run(&def, &dir).unwrap();
let _ = std::fs::remove_dir_all(&dir);
let bad = final_state.steps.iter().find(|s| s.id == "bad").unwrap();
assert_eq!(bad.state, StepState::Failed);
}
#[test]
fn run_resumes_compatible_persisted_state() {
let dir = tempfile::tempdir().unwrap();
let mut def = two_step_def();
def.steps[0].run = "false".to_string();
let mut state = init_state(&def);
set_state(&mut state, "step1", StepState::Done, Some(0));
let state_path = dir
.path()
.join(".ctx")
.join("godmode")
.join("workflow-test-wf.json");
persist_state(&state, &state_path).unwrap();
let final_state = run(&def, dir.path()).unwrap();
assert!(final_state.steps.iter().all(|s| s.state == StepState::Done));
}
#[test]
fn run_rejects_persisted_state_after_definition_drift() {
let dir = tempfile::tempdir().unwrap();
let def = two_step_def();
let state_path = dir
.path()
.join(".ctx")
.join("godmode")
.join("workflow-test-wf.json");
persist_state(&init_state(&def), &state_path).unwrap();
let mut changed = def;
changed.steps[1].run = "false".to_string();
let error = run(&changed, dir.path()).unwrap_err();
assert!(error.to_string().contains("definition drift"));
}
#[test]
fn run_returns_persistence_write_errors() {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join(".ctx"), "not a directory").unwrap();
let error = run(&two_step_def(), dir.path()).unwrap_err();
assert!(error.to_string().contains("workflow state"));
}
}