fix: build release packages once (#8192)

Author: chubes4

src/core/release/checkout_guard.rs

@@ -198,7 +198,7 @@ mod tests {
     }
 
     #[test]
-    fn restore_after_failure_returns_to_original_branch_and_removes_new_untracked() {
+    fn package_failure_restores_release_commit_and_generated_files() {
         let temp = init_repo();
         let dir = temp.path();
         run_git(dir, &["checkout", "-q", "-b", "release-local"]);
@@ -207,9 +207,10 @@ mod tests {
             .expect("capture")
             .expect("git repo");
 
-        run_git(dir, &["checkout", "-q", "main"]);
         std::fs::write(dir.join("generated.txt"), "release output\n").expect("write generated");
         std::fs::write(dir.join("file.txt"), "mutated\n").expect("mutate tracked");
+        run_git(dir, &["add", "file.txt"]);
+        run_git(dir, &["commit", "-q", "-m", "release: v1.0.0"]);
 
         guard.restore_after_failure().expect("restore");
 
@@ -223,6 +224,10 @@ mod tests {
         );
         assert_eq!(git_stdout_for_test(dir, &["status", "--porcelain=v1"]), "");
         assert!(!dir.join("generated.txt").exists());
+        assert_eq!(
+            std::fs::read_to_string(dir.join("file.txt")).unwrap(),
+            "main\n"
+        );
     }
 
     #[test]

src/core/release/execution_dispatch.rs

@@ -40,14 +40,19 @@ pub(super) fn execute_release_plan_step(
             Ok(Some(run_changelog_bootstrap_preflight(step, context)))
         }
         "preflight.package" => Ok(Some(
-            executor::package_preflight::run_package_preflight(
-                context.extensions,
-                context.component,
-                context.component_id,
-                &context.component.local_path,
-                context.options.skip_build_validation,
-            )
-            .unwrap_or_else(|err| failed_result("preflight.package", "preflight.package", err)),
+            executor::package_preflight::run_package_preflight(&context.component.local_path)
+                .map(|_| {
+                    executor::step_success(
+                        "preflight.package",
+                        "preflight.package",
+                        Some(serde_json::json!({
+                            "component_path": context.component.local_path,
+                            "validated_action": "release.package.guards",
+                        })),
+                        Vec::new(),
+                    )
+                })
+                .unwrap_or_else(|err| failed_result("preflight.package", "preflight.package", err)),
         )),
         "preflight.tag_availability" => {
             let tag_name = step
@@ -109,6 +114,14 @@ pub(super) fn execute_release_plan_step(
                 None,
                 context.options.skip_build_validation,
             )
+            .and_then(|result| {
+                executor::package_preflight::validate_package_completeness(
+                    context.component,
+                    std::path::Path::new(&context.component.local_path),
+                    &context.state.artifacts,
+                )?;
+                Ok(result)
+            })
             .unwrap_or_else(|err| failed_result("package", "package", err)),
         )),
         "artifacts.inventory" => {
@@ -729,6 +742,7 @@ mod tests {
         release_step_is_show_stopper, release_step_unexpected_dirty_files, ReleaseExecutionContext,
     };
     use crate::core::component::{Component, ComponentScriptsConfig, VersionTarget};
+    use crate::core::extension::ExtensionManifest;
     use crate::core::plan::PlanStep;
     use crate::core::release::types::{
         ReleaseOptions, ReleaseState, ReleaseStepResult, ReleaseStepStatus,
@@ -774,6 +788,135 @@ mod tests {
         assert!(!release_step_is_plan_only(&plan_step("deploy")));
     }
 
+    #[test]
+    fn release_package_builds_once_and_validates_the_uploaded_durable_bytes() {
+        crate::test_support::with_isolated_home(|_| {
+            let repo = tempfile::tempdir().expect("repo");
+            std::fs::write(repo.path().join("plugin.php"), "<?php\n").expect("plugin");
+            run_in(repo.path(), &["git", "init", "-q"]);
+            configure_git_user(repo.path());
+            run_in(repo.path(), &["git", "add", "plugin.php"]);
+            run_in(repo.path(), &["git", "commit", "-qm", "Initial commit"]);
+            let counter = repo.path().join("package-count");
+            let package = package_extension(&format!(
+                "n=$(cat '{counter}' 2>/dev/null || echo 0); echo $((n + 1)) > '{counter}'; \
+                 mkdir -p build/stage; cp plugin.php build/stage/plugin.php; \
+                 (cd build && zip -q fixture.zip stage/plugin.php); \
+                 printf '[{{\"path\":\"build/fixture.zip\",\"type\":\"archive\"}}]'",
+                counter = counter.display(),
+            ));
+            crate::core::extension::save_manifest(&package).expect("save package extension");
+
+            let component = Component {
+                id: "fixture".to_string(),
+                local_path: repo.path().to_string_lossy().to_string(),
+                ..Component::default()
+            };
+            let options = ReleaseOptions::default();
+            let extensions = vec![package];
+            let mut context = ReleaseExecutionContext {
+                component: &component,
+                extensions: &extensions,
+                component_id: "fixture",
+                options: &options,
+                state: ReleaseState {
+                    version: Some("1.2.3".to_string()),
+                    ..ReleaseState::default()
+                },
+                publish_failed: false,
+            };
+
+            execute_release_plan_step(&plan_step("preflight.package"), &mut context)
+                .expect("preflight dispatch")
+                .expect("preflight result");
+            assert!(!counter.exists(), "preflight must not run release.package");
+
+            let result = execute_release_plan_step(&plan_step("package"), &mut context)
+                .expect("package dispatch")
+                .expect("package result");
+            assert_eq!(result.status, ReleaseStepStatus::Success);
+            assert_eq!(
+                std::fs::read_to_string(&counter).expect("count").trim(),
+                "1"
+            );
+            let durable = context.state.artifacts[0]
+                .durable_path
+                .as_ref()
+                .expect("durable artifact");
+            assert_eq!(
+                std::fs::read(repo.path().join("build/fixture.zip")).expect("source artifact"),
+                std::fs::read(durable).expect("uploaded artifact"),
+            );
+        });
+    }
+
+    #[test]
+    fn final_package_completeness_failure_stops_before_publication() {
+        crate::test_support::with_isolated_home(|_| {
+            let repo = tempfile::tempdir().expect("repo");
+            std::fs::create_dir_all(repo.path().join("agents")).expect("agents");
+            std::fs::write(repo.path().join("plugin.php"), "<?php\n").expect("plugin");
+            std::fs::write(repo.path().join("agents/runtime.php"), "<?php\n").expect("runtime");
+            run_in(repo.path(), &["git", "init", "-q"]);
+            configure_git_user(repo.path());
+            run_in(
+                repo.path(),
+                &["git", "add", "plugin.php", "agents/runtime.php"],
+            );
+            run_in(repo.path(), &["git", "commit", "-qm", "Initial commit"]);
+            let package = package_extension(
+                "mkdir -p build/stage; cp plugin.php build/stage/plugin.php; (cd build && zip -q fixture.zip stage/plugin.php); printf '[{\"path\":\"build/fixture.zip\",\"type\":\"archive\"}]'",
+            );
+            crate::core::extension::save_manifest(&package).expect("save package extension");
+
+            let component = Component {
+                id: "fixture".to_string(),
+                local_path: repo.path().to_string_lossy().to_string(),
+                ..Component::default()
+            };
+            let options = ReleaseOptions::default();
+            let extensions = vec![package];
+            let mut context = ReleaseExecutionContext {
+                component: &component,
+                extensions: &extensions,
+                component_id: "fixture",
+                options: &options,
+                state: ReleaseState {
+                    version: Some("1.2.3".to_string()),
+                    ..ReleaseState::default()
+                },
+                publish_failed: false,
+            };
+
+            let result = execute_release_plan_step(&plan_step("package"), &mut context)
+                .expect("package dispatch")
+                .expect("package result");
+            assert_eq!(result.status, ReleaseStepStatus::Failed);
+            assert!(result
+                .error
+                .as_deref()
+                .unwrap_or_default()
+                .contains("agents/runtime.php"));
+            assert!(release_step_is_show_stopper(&result));
+        });
+    }
+
+    fn package_extension(command: &str) -> ExtensionManifest {
+        let mut extension: ExtensionManifest = serde_json::from_value(serde_json::json!({
+            "name": "Fixture Packager",
+            "version": "1.0.0",
+            "actions": [{
+                "id": "release.package",
+                "label": "Package release",
+                "type": "command",
+                "command": command,
+            }],
+        }))
+        .expect("package extension");
+        extension.id = "fixture-packager".to_string();
+        extension
+    }
+
     #[test]
     fn dependency_preflight_hydrates_before_lint_self_check() {
         let temp = tempfile::tempdir().expect("tempdir");

src/core/release/executor.rs

@@ -907,7 +907,7 @@ mod tests {
     }
 
     #[test]
-    fn package_preflight_payload_distinguishes_staging_path_from_source_path() {
+    fn package_preflight_runs_guards_without_building_an_artifact() {
         crate::test_support::with_isolated_home(|_| {
             let component = tempfile::tempdir().expect("component tempdir");
             run_in(component.path(), &["git", "init"]);
@@ -931,45 +931,17 @@ mod tests {
             );
             crate::core::extension::save_manifest(&package).expect("save package extension");
 
-            let result = package_preflight::run_package_preflight(
-                &[package],
-                &Component {
-                    id: "fixture".to_string(),
-                    local_path: component.path().to_string_lossy().to_string(),
-                    ..Component::default()
-                },
-                "fixture",
-                &component.path().to_string_lossy(),
-                false,
-            )
-            .expect("package preflight");
+            package_preflight::run_package_preflight(&component.path().to_string_lossy())
+                .expect("package guards");
 
-            assert_eq!(result.status, ReleaseStepStatus::Success);
-            let payload: serde_json::Value = serde_json::from_str(
-                &std::fs::read_to_string(&payload_out).expect("payload output"),
-            )
-            .expect("payload json");
-            assert_eq!(
-                payload["release"]["source_path"].as_str(),
-                Some(component.path().to_string_lossy().as_ref())
-            );
-            assert_ne!(
-                payload["release"]["local_path"].as_str(),
-                payload["release"]["source_path"].as_str()
-            );
-            assert_eq!(
-                std::fs::read_to_string(&source_env_out).expect("source env"),
-                component.path().to_string_lossy()
-            );
-            assert_eq!(
-                std::fs::read_to_string(&component_env_out).expect("component env"),
-                payload["release"]["local_path"].as_str().unwrap()
-            );
+            assert!(!payload_out.exists());
+            assert!(!source_env_out.exists());
+            assert!(!component_env_out.exists());
         });
     }
 
     #[test]
-    fn package_preflight_materializes_repo_root_for_subdirectory_component() {
+    fn package_preflight_does_not_materialize_a_repository_copy() {
         crate::test_support::with_isolated_home(|_| {
             let repo = tempfile::tempdir().expect("repo tempdir");
             std::fs::write(repo.path().join("build-input.txt"), "repo-root-input")
@@ -998,27 +970,14 @@ mod tests {
             );
             crate::core::extension::save_manifest(&package).expect("save package extension");
 
-            let result = package_preflight::run_package_preflight(
-                &[package],
-                &Component {
-                    id: "fixture".to_string(),
-                    local_path: component.to_string_lossy().to_string(),
-                    ..Component::default()
-                },
-                "fixture",
-                &component.to_string_lossy(),
-                false,
-            )
-            .expect("package preflight");
-
-            assert_eq!(result.status, ReleaseStepStatus::Success);
-            let data = result.data.expect("preflight data");
-            assert_eq!(data["validated_action"].as_str(), Some("release.package"));
+            package_preflight::run_package_preflight(&component.to_string_lossy())
+                .expect("package guards");
+            assert!(!component.join("build").exists());
         });
     }
 
     #[test]
-    fn package_preflight_failure_includes_actionable_diagnostics() {
+    fn package_failure_surfaces_actionable_output() {
         crate::test_support::with_isolated_home(|_| {
             let component = tempfile::tempdir().expect("component tempdir");
             let package = release_package_extension(
@@ -1027,59 +986,19 @@ mod tests {
             );
             crate::core::extension::save_manifest(&package).expect("save package extension");
 
-            let err = package_preflight::run_package_preflight(
+            let mut state = ReleaseState::default();
+            let err = run_package(
                 &[package],
-                &Component {
-                    id: "fixture".to_string(),
-                    local_path: component.path().to_string_lossy().to_string(),
-                    ..Component::default()
-                },
+                &mut state,
                 "fixture",
                 &component.path().to_string_lossy(),
+                None,
                 true,
             )
-            .expect_err("failing package preflight should surface diagnostics");
+            .expect_err("failing final package should surface output");
 
-            let diagnostic = &err.details["diagnostic"];
-            assert_eq!(diagnostic["component_id"].as_str(), Some("fixture"));
-            assert_eq!(
-                diagnostic["package_root"].as_str(),
-                Some(component.path().to_string_lossy().as_ref())
-            );
-            assert!(diagnostic["build_cwd"]
-                .as_str()
-                .unwrap_or_default()
-                .contains("homeboy-release-package-preflight"));
-            assert!(diagnostic["materialized_temp_root"]
-                .as_str()
-                .unwrap_or_default()
-                .contains("homeboy-release-package-preflight"));
-            assert_eq!(diagnostic["exit_code"].as_i64(), Some(9));
-            let command = diagnostic["command"].as_str().expect("command");
-            assert!(command.contains("building package"));
-            assert!(command.contains("missing tsconfig.base.json"));
-            assert!(command.contains("exit 9"));
-            assert_eq!(
-                diagnostic["config_fields"]["component.local_path"].as_str(),
-                Some(component.path().to_string_lossy().as_ref())
-            );
-            assert_eq!(
-                diagnostic["config_fields"]["config.skip_build_validation"].as_bool(),
-                Some(true)
-            );
-            assert!(diagnostic["relevant_error_lines"]
-                .as_array()
-                .expect("relevant error lines")
-                .iter()
-                .any(|line| line.as_str() == Some("error: missing tsconfig.base.json")));
-
-            let artifact_path = err.details["artifact_path"]
-                .as_str()
-                .expect("artifact path");
-            assert!(std::path::Path::new(artifact_path).is_file());
-            let artifact = std::fs::read_to_string(artifact_path).expect("diagnostic artifact");
-            assert!(artifact.contains("missing tsconfig.base.json"));
-            assert!(err.message.contains("diagnostic artifact"));
+            assert!(err.message.contains("missing tsconfig.base.json"));
+            assert_eq!(err.details["source"]["exit_code"].as_i64(), Some(9));
         });
     }