From 27df589cc813c8c67acb1c1c620c2bb67dbce0d6 Mon Sep 17 00:00:00 2001 From: Scott Werner Date: Mon, 26 Oct 2026 21:56:15 -0400 Subject: [PATCH] Simplify child auto-approval start path and tests - Build the start status and lifecycle records from one match on the child start decision, and move the resume short-circuit into child_start_decision. - Read the parent's projection without waiting for its projector to settle: the parent's settings are fixed at create. Keep the error context the projection helper provided. - Collapse the AutoApproved projection fold into one get_or_insert. - Resolve server.approvals.allow_child_auto_approval with the defaults.toml expect pattern instead of a second default. - Keep doc-comment code spans on one line. - Deduplicate the new server tests: create_run_with_bearer delegates to create_run_with_workflow_config, create_child_as_worker takes optional args, JWT app builders are shared, lifecycle checks reuse lifecycle_transition_count, and pending/managed-status assertions use helpers. - Fix a needless_raw_string_hashes lint and apply rustfmt. Co-Authored-By: Claude Opus 5.5 --- .../src/server/handler/lifecycle.rs | 66 +++--- lib/apps/fabro-server/src/server/tests.rs | 195 ++++++------------ .../fabro-petri/src/projection/platform.rs | 22 +- lib/foundation/fabro-config/src/lib.rs | 7 +- .../fabro-config/src/resolve/server.rs | 2 +- .../fabro-config/src/tests/resolve_run.rs | 4 +- .../fabro-types/src/settings/run.rs | 8 +- 7 files changed, 117 insertions(+), 187 deletions(-) diff --git a/lib/apps/fabro-server/src/server/handler/lifecycle.rs b/lib/apps/fabro-server/src/server/handler/lifecycle.rs index 4d2c01f1a..86bc4ac9f 100644 --- a/lib/apps/fabro-server/src/server/handler/lifecycle.rs +++ b/lib/apps/fabro-server/src/server/handler/lifecycle.rs @@ -1,6 +1,7 @@ use std::collections::HashSet; use std::sync::Arc; +use anyhow::Context as _; use chrono::Utc; use fabro_store::platform_records::{PlatformRecord, RunLifecycleKind, RunLifecycleRecord}; use tokio::time::{Instant, sleep_until}; @@ -129,7 +130,8 @@ enum ChildStartDecision { AutoApproved, } -/// Decide whether a non-resume start of `run_state` needs operator approval. +/// Decide whether a start of `run_state` needs operator approval. A resume +/// is never gated. /// /// A worker-started child is auto-approved only when the server enables the /// capability and the spawning parent's persisted workflow settings opt in. @@ -140,8 +142,12 @@ enum ChildStartDecision { async fn child_start_decision( state: &AppState, run_state: &fabro_store::RunProjection, + resume: bool, actor: &Principal, ) -> Result { + if resume { + return Ok(ChildStartDecision::NotGated); + } let Principal::Worker { run_id } = actor else { return Ok(ChildStartDecision::NotGated); }; @@ -154,15 +160,25 @@ async fn child_start_decision( // could approve it, so operator approval is required. return Ok(ChildStartDecision::ApprovalRequired); } - if !state.server_settings().server.approvals.allow_child_auto_approval { + if !state + .server_settings() + .server + .approvals + .allow_child_auto_approval + { return Ok(ChildStartDecision::ApprovalRequired); } // The spawning parent owns the policy: read it from the parent's own // persisted settings, not from the child's parent link, so reassigning // the link cannot change the decision. A parent whose projection is gone - // fails closed to the approval gate. - let parent = run_records::projection(state, *run_id) + // fails closed to the approval gate. The parent's settings are fixed at + // create, so there is no need to wait for its projector to settle. + let parent = state + .stores + .run_summaries + .load_petri_projection(run_id) .await + .with_context(|| format!("loading the projection of parent run {run_id}")) .map_err(|err| ApiError::new(StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?; let opted_in = parent.is_some_and(|parent| parent.spec.settings.run.children.auto_approve); Ok(if opted_in { @@ -189,40 +205,30 @@ pub(super) async fn queue_run( .root() .to_path_buf(); let dot_source = run_state.spec.graph_source.clone().unwrap_or_default(); - let decision = if resume { - ChildStartDecision::NotGated - } else { - child_start_decision(state, run_state, &actor).await? - }; - let approval_required = matches!(decision, ChildStartDecision::ApprovalRequired); let mut start_requested = RunLifecycleRecord::new(RunLifecycleKind::StartRequested); start_requested.source = Some(if resume { "resume" } else { "start" }.to_string()); - let next_status = if approval_required { - RunStatus::Pending { - reason: PendingReason::ApprovalRequired, + let (next_status, next) = match child_start_decision(state, run_state, resume, &actor).await? { + ChildStartDecision::NotGated => (RunStatus::Runnable, vec![run_records::runnable( + RunRunnableSource::StartRequested, + )]), + ChildStartDecision::ApprovalRequired => { + let status = RunStatus::Pending { + reason: PendingReason::ApprovalRequired, + }; + (status, vec![run_records::transition( + RunLifecycleKind::Pending, + status, + )]) } - } else { - RunStatus::Runnable - }; - let records = match decision { - ChildStartDecision::NotGated => vec![ - start_requested, - run_records::runnable(RunRunnableSource::StartRequested), - ], - ChildStartDecision::ApprovalRequired => vec![ - start_requested, - run_records::transition(RunLifecycleKind::Pending, next_status), - ], // Policy approval is recorded as its own auditable transition before // the runnable state, so the projection never shows a transitive // pending state for an auto-approved child. - ChildStartDecision::AutoApproved => vec![ - start_requested, + ChildStartDecision::AutoApproved => (RunStatus::Runnable, vec![ RunLifecycleRecord::new(RunLifecycleKind::AutoApproved), run_records::runnable(RunRunnableSource::AutoApproved), - ], + ]), }; - for record in records { + for record in std::iter::once(start_requested).chain(next) { if let Err(err) = run_records::lifecycle(state, id, record).await { return Err(ApiError::new( StatusCode::INTERNAL_SERVER_ERROR, @@ -249,7 +255,7 @@ pub(super) async fn queue_run( ); } - if !approval_required { + if next_status == RunStatus::Runnable { state.scheduler_notify.notify_one(); } Ok(()) diff --git a/lib/apps/fabro-server/src/server/tests.rs b/lib/apps/fabro-server/src/server/tests.rs index 5f4b740fe..78fad75e9 100644 --- a/lib/apps/fabro-server/src/server/tests.rs +++ b/lib/apps/fabro-server/src/server/tests.rs @@ -627,15 +627,21 @@ fn jwt_auth_mode() -> AuthMode { } fn jwt_auth_state() -> Arc { - test_app_state_with_session_key( - default_test_server_settings(), - RunLayer::default(), - Some(TEST_SESSION_SECRET), - ) + jwt_auth_state_with(default_test_server_settings(), RunLayer::default()) +} + +fn jwt_auth_state_with( + server_settings: fabro_types::ServerSettings, + run_defaults: RunLayer, +) -> Arc { + test_app_state_with_session_key(server_settings, run_defaults, Some(TEST_SESSION_SECRET)) } fn jwt_auth_app() -> (Arc, Router) { - let state = jwt_auth_state(); + jwt_auth_app_with_state(jwt_auth_state()) +} + +fn jwt_auth_app_with_state(state: Arc) -> (Arc, Router) { let app = build_router(Arc::clone(&state), jwt_auth_mode()); (state, app) } @@ -681,25 +687,7 @@ fn issue_test_run_tools_worker_token(run_id: &RunId) -> String { } async fn create_run_with_bearer(app: &Router, bearer: &str) -> RunId { - let response = app - .clone() - .oneshot( - Request::builder() - .method("POST") - .uri(api("/runs")) - .header(header::AUTHORIZATION, format!("Bearer {bearer}")) - .header(header::CONTENT_TYPE, "application/json") - .body(Body::from( - test_intent_with_bearer(app, "workflow.fabro", MINIMAL_DOT, None, Some(bearer)) - .await - .to_string(), - )) - .unwrap(), - ) - .await - .unwrap(); - let body = response_json!(response, StatusCode::CREATED).await; - body["id"].as_str().unwrap().parse().unwrap() + create_run_with_workflow_config(app, bearer, None).await } fn bearer_request(method: Method, path: &str, bearer: &str, body: Body) -> Request { @@ -8005,13 +7993,10 @@ methods = ["dev-token"] allow_child_auto_approval = {allow_child_auto_approval} "# ); - let state = test_app_state_with_session_key( + jwt_auth_app_with_state(jwt_auth_state_with( server_settings_from_toml(&source), manifest_run_defaults_from_toml(&source), - Some(TEST_SESSION_SECRET), - ); - let app = build_router(Arc::clone(&state), jwt_auth_mode()); - (state, app) + )) } async fn create_run_with_workflow_config( @@ -8041,6 +8026,7 @@ async fn create_child_as_worker( worker_token: &str, parent_run_id: RunId, registrar_bearer: &str, + args: Option, ) -> RunId { let mut child_intent = test_intent_with_bearer( app, @@ -8051,6 +8037,9 @@ async fn create_child_as_worker( ) .await; child_intent["parent_id"] = json!(parent_run_id.to_string()); + if let Some(args) = args { + child_intent["args"] = args; + } let response = app .clone() .oneshot(json_bearer_request( @@ -8077,20 +8066,19 @@ async fn start_run_as_worker(app: &Router, worker_token: &str, run_id: RunId) -> .unwrap() } -async fn child_lifecycle_transitions(state: &AppState, run_id: RunId) -> Vec { - state - .stores - .run_summaries - .platform_records() - .read(&run_id) - .await - .unwrap() - .iter() - .filter_map(|stored| match &stored.record { - PlatformRecord::RunLifecycle(record) => Some(record.transition.to_string()), - _ => None, +fn assert_pending_approval(body: &serde_json::Value) { + assert_eq!( + run_json_status(body), + &json!({ + "kind": "pending", + "reason": "approval_required" }) - .collect() + ); +} + +fn assert_managed_status(state: &AppState, run_id: RunId, status: RunStatus) { + let runs = state.runs.lock().expect("runs lock poisoned"); + assert_eq!(runs.get(&run_id).map(|run| run.status), Some(status)); } #[tokio::test] @@ -8101,32 +8089,22 @@ async fn child_start_stays_pending_when_only_the_workflow_opts_in() { create_run_with_workflow_config(&app, &user_jwt, Some(CHILD_AUTO_APPROVE_TOML)).await; let worker_token = issue_test_run_tools_worker_token(&parent_run_id); let child_run_id = - create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt).await; + create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt, None).await; let pending_body = response_json!( start_run_as_worker(&app, &worker_token, child_run_id).await, StatusCode::OK ) .await; - assert_eq!( - run_json_status(&pending_body), - &json!({ - "kind": "pending", - "reason": "approval_required" - }) - ); + assert_pending_approval(&pending_body); assert_eq!( pending_body["lifecycle"]["approval"]["state"].as_str(), Some("pending") ); - let runs = state.runs.lock().expect("runs lock poisoned"); - assert_eq!( - runs.get(&child_run_id).map(|run| run.status), - Some(RunStatus::Pending { - reason: fabro_types::PendingReason::ApprovalRequired, - }) - ); + assert_managed_status(&state, child_run_id, RunStatus::Pending { + reason: fabro_types::PendingReason::ApprovalRequired, + }); } #[tokio::test] @@ -8136,28 +8114,18 @@ async fn child_start_stays_pending_when_only_the_server_opts_in() { let parent_run_id = create_run_with_workflow_config(&app, &user_jwt, None).await; let worker_token = issue_test_run_tools_worker_token(&parent_run_id); let child_run_id = - create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt).await; + create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt, None).await; let pending_body = response_json!( start_run_as_worker(&app, &worker_token, child_run_id).await, StatusCode::OK ) .await; - assert_eq!( - run_json_status(&pending_body), - &json!({ - "kind": "pending", - "reason": "approval_required" - }) - ); + assert_pending_approval(&pending_body); - let runs = state.runs.lock().expect("runs lock poisoned"); - assert_eq!( - runs.get(&child_run_id).map(|run| run.status), - Some(RunStatus::Pending { - reason: fabro_types::PendingReason::ApprovalRequired, - }) - ); + assert_managed_status(&state, child_run_id, RunStatus::Pending { + reason: fabro_types::PendingReason::ApprovalRequired, + }); } #[tokio::test] @@ -8168,7 +8136,7 @@ async fn child_start_is_auto_approved_when_both_opt_ins_are_enabled() { create_run_with_workflow_config(&app, &user_jwt, Some(CHILD_AUTO_APPROVE_TOML)).await; let worker_token = issue_test_run_tools_worker_token(&parent_run_id); let child_run_id = - create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt).await; + create_child_as_worker(&app, &worker_token, parent_run_id, &user_jwt, None).await; let approved_body = response_json!( start_run_as_worker(&app, &worker_token, child_run_id).await, @@ -8191,15 +8159,17 @@ async fn child_start_is_auto_approved_when_both_opt_ins_are_enabled() { // The lifecycle history records one deliberate policy approval; the // projection never shows a transient pending state. - let transitions = child_lifecycle_transitions(state.as_ref(), child_run_id).await; - assert!(transitions.contains(&"auto_approved".to_string())); - assert!(!transitions.contains(&"pending".to_string())); - - let runs = state.runs.lock().expect("runs lock poisoned"); + let records = platform_records(&state, child_run_id).await; assert_eq!( - runs.get(&child_run_id).map(|run| run.status), - Some(RunStatus::Runnable) + lifecycle_transition_count(&records, RunLifecycleKind::AutoApproved), + 1 ); + assert_eq!( + lifecycle_transition_count(&records, RunLifecycleKind::Pending), + 0 + ); + + assert_managed_status(&state, child_run_id, RunStatus::Runnable); } #[tokio::test] @@ -8208,42 +8178,21 @@ async fn child_start_ignores_client_auto_approve_args_without_policy() { let user_jwt = issue_test_user_jwt(); let parent_run_id = create_run_with_bearer(&app, &user_jwt).await; let worker_token = issue_test_run_tools_worker_token(&parent_run_id); - - let mut child_intent = test_intent_with_bearer( + let child_run_id = create_child_as_worker( &app, - "workflow.fabro", - MINIMAL_DOT, - None, - Some(&user_jwt), + &worker_token, + parent_run_id, + &user_jwt, + Some(json!({ "auto_approve": true })), ) .await; - child_intent["parent_id"] = json!(parent_run_id.to_string()); - child_intent["args"] = json!({ "auto_approve": true }); - let response = app - .clone() - .oneshot(json_bearer_request( - Method::POST, - "/runs", - &worker_token, - &child_intent, - )) - .await - .unwrap(); - let child_body = response_json!(response, StatusCode::CREATED).await; - let child_run_id = child_body["id"].as_str().unwrap().parse::().unwrap(); let pending_body = response_json!( start_run_as_worker(&app, &worker_token, child_run_id).await, StatusCode::OK ) .await; - assert_eq!( - run_json_status(&pending_body), - &json!({ - "kind": "pending", - "reason": "approval_required" - }) - ); + assert_pending_approval(&pending_body); } #[tokio::test] @@ -8263,13 +8212,7 @@ async fn worker_start_of_runs_it_did_not_spawn_fails_closed_to_approval() { StatusCode::OK ) .await; - assert_eq!( - run_json_status(&pending_body), - &json!({ - "kind": "pending", - "reason": "approval_required" - }) - ); + assert_pending_approval(&pending_body); // Starting a run the worker did not spawn fails closed to the approval // gate instead of skipping it. @@ -8278,23 +8221,11 @@ async fn worker_start_of_runs_it_did_not_spawn_fails_closed_to_approval() { StatusCode::OK ) .await; - assert_eq!( - run_json_status(&pending_body), - &json!({ - "kind": "pending", - "reason": "approval_required" - }) - ); - let projection = state - .load_run_projection(&unrelated_run_id) - .await - .unwrap(); - assert_eq!( - projection.status, - RunStatus::Pending { - reason: fabro_types::PendingReason::ApprovalRequired, - } - ); + assert_pending_approval(&pending_body); + let projection = state.load_run_projection(&unrelated_run_id).await.unwrap(); + assert_eq!(projection.status, RunStatus::Pending { + reason: fabro_types::PendingReason::ApprovalRequired, + }); } #[tokio::test] diff --git a/lib/components/fabro-petri/src/projection/platform.rs b/lib/components/fabro-petri/src/projection/platform.rs index 74a174539..d45c3b7fa 100644 --- a/lib/components/fabro-petri/src/projection/platform.rs +++ b/lib/components/fabro-petri/src/projection/platform.rs @@ -225,20 +225,14 @@ fn fold_lifecycle(projection: &mut RunProjection, record: &RunLifecycleRecord, a // A child start approved by policy: no request preceded the // decision, so the approval is created approved in one step // rather than projected through a transient pending state. - match projection.approval.as_mut() { - Some(approval) => { - approval.state = RunApprovalState::Approved; - approval.decided_at = Some(at); - } - None => { - projection.approval = Some(RunApproval { - state: RunApprovalState::Approved, - requested_at: at, - decided_at: Some(at), - denial_reason: None, - }); - } - } + let approval = projection.approval.get_or_insert(RunApproval { + state: RunApprovalState::Approved, + requested_at: at, + decided_at: None, + denial_reason: None, + }); + approval.state = RunApprovalState::Approved; + approval.decided_at = Some(at); } Kind::Denied => { if let Some(approval) = projection.approval.as_mut() { diff --git a/lib/foundation/fabro-config/src/lib.rs b/lib/foundation/fabro-config/src/lib.rs index 31dd029ac..5db2b775a 100644 --- a/lib/foundation/fabro-config/src/lib.rs +++ b/lib/foundation/fabro-config/src/lib.rs @@ -53,10 +53,9 @@ pub use layers::{ RunModelControlsLayer, RunModelLayer, RunPrepareLayer, RunPullRequestLayer, RunRunBranchLayer, RunScmLayer, ScmGitHubLayer, ServerApiLayer, ServerApprovalsLayer, ServerArtifactsLayer, ServerAuthGithubLayer, ServerAuthLayer, ServerIntegrationsLayer, ServerLayer, - ServerListenLayer, ServerLoggingLayer, - ServerSandboxLayer, ServerSandboxProviderLayer, ServerSandboxProvidersLayer, - ServerSchedulerLayer, ServerStorageLayer, ServerWebLayer, SettingsLayer, SlackIntegrationLayer, - StickyMap, StringOrSplice, WorkflowLayer, + ServerListenLayer, ServerLoggingLayer, ServerSandboxLayer, ServerSandboxProviderLayer, + ServerSandboxProvidersLayer, ServerSchedulerLayer, ServerStorageLayer, ServerWebLayer, + SettingsLayer, SlackIntegrationLayer, StickyMap, StringOrSplice, WorkflowLayer, }; pub use logging::{resolve_log_destination, resolve_log_destination_with_env}; pub use parse::ParseError; diff --git a/lib/foundation/fabro-config/src/resolve/server.rs b/lib/foundation/fabro-config/src/resolve/server.rs index 7b60f9ac9..14537af1d 100644 --- a/lib/foundation/fabro-config/src/resolve/server.rs +++ b/lib/foundation/fabro-config/src/resolve/server.rs @@ -55,7 +55,7 @@ pub fn resolve_server(layer: &ServerLayer, errors: &mut Vec) -> Se .approvals .as_ref() .and_then(|approvals| approvals.allow_child_auto_approval) - .unwrap_or(false), + .expect("defaults.toml should provide server.approvals.allow_child_auto_approval"), }, logging: ServerLoggingSettings { level: layer diff --git a/lib/foundation/fabro-config/src/tests/resolve_run.rs b/lib/foundation/fabro-config/src/tests/resolve_run.rs index a3774e558..c3cdc1054 100644 --- a/lib/foundation/fabro-config/src/tests/resolve_run.rs +++ b/lib/foundation/fabro-config/src/tests/resolve_run.rs @@ -2013,12 +2013,12 @@ fn run_children_auto_approve_defaults_to_false() { #[test] fn run_children_auto_approve_resolves_from_workflow_toml() { let settings = super::workflow_settings_from_toml( - r#" + r" _version = 1 [run.children] auto_approve = true -"#, +", ) .expect("[run.children] should resolve") .run; diff --git a/lib/foundation/fabro-types/src/settings/run.rs b/lib/foundation/fabro-types/src/settings/run.rs index 1862a8470..c712cbd2f 100644 --- a/lib/foundation/fabro-types/src/settings/run.rs +++ b/lib/foundation/fabro-types/src/settings/run.rs @@ -604,10 +604,10 @@ pub struct RunIntegrationsSettings { /// /// This governs the child's *lifecycle* start decision (whether the child /// waits for operator approval), not the child's own agent-interaction -/// approval posture (`run.execution.approval`, which `RunIntentArgs -/// .auto_approve` maps to). It is the workflow half of the child -/// auto-approval opt-in; the server half is `server.approvals -/// .allow_child_auto_approval`, and both must be enabled. +/// approval posture (`run.execution.approval`, which +/// `RunIntentArgs.auto_approve` maps to). It is the workflow half of the +/// child auto-approval opt-in; the server half is +/// `server.approvals.allow_child_auto_approval`, and both must be enabled. #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)] #[serde(default)] pub struct RunChildrenSettings {