Hook parsing in native builds runs between READ_PACKAGE_JSON and
INSTALL_DEPENDENCIES and logged through the phase-less logger, so every
native build with hooks showed an "Unknown build phase" log group.
Ignore unknown and unrun hook keys silently in both the native and the
steps parser, let the eas/checkout step print the working-directory line
itself, and drop the after-hook failure line that the failing hook step
already logs.
* [eas-cli][local-build-plugin] Deprecate Node 20, use Node 22 in CI
Print a deprecation warning from the eas-cli and local-build-plugin
bin scripts when running on Node.js < 22. Develop and test on Node.js
22: bump mise, drop 20.18.3 from the test matrix, and move to
@tsconfig/node22 and @types/node 22. Published engines are unchanged.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
# Why
Follow-up to #4399 to upgrade typescript to latest version.
# How
Tell claude to upgrade to 6.x.
# Test Plan
CI, tests
<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
# Why
This is a bit behind in typescript. 6.x is where most of our repos live.
First step is to get to highest 5.x.
# How
Tell claude to upgrade to highest 5.x.
It required a new version of `https-proxy-agent` to be compatible with new node types.
# Test Plan
`yarn start`, tests.
* [steps] Report a broken composite if: on the call, not an inner step
* [steps] Simplify condition evaluation error handling by building the erro message in the error constructor
* [steps] Composite functions: skip the outputs step when the call never ran
* [steps] test coverage improvement: recursive anyAuthoredChildExecuted when a nested call has no outputs
`fast-glob` and `arg` were imported but not declared in their packages,
resolving only via workspace hoisting. Declare them explicitly so the
packages keep working when installed standalone.
* [eas-cli] Validate local composite functions referenced from workflow hooks
* extract the local composite function loader into @expo/steps
* skip validation when project_root_directory is set
* Validate defaults.hooks and remove project_root_directory skip
* [build-tools] Load composite function catalogs for hook steps
* do lazy loading of composite functions in hooks
* report the hook key on composite function load errors
* validate hook step functions only for reached anchors
* cleanup hook key parsing
* warn on unknown hook key
* share one composite function catalog across hook keys
* report the hook key on all composite step config errors
* report the hook key on composite expansion errors
# Why
Hook steps currently reject `uses: ./...` local composite functions. Users should be able to reuse the same composites in hooks as in the main workflow.
# How
A composite function used in a hook is expanded into its inner steps at parse time, the same way it is in the main workflow, and the whole expansion becomes a single hook entry. The step's `if:` gates the expansion as a whole.
Hook construction now takes a catalog of composite functions. Without it, referencing a composite fails with a missing-function error instead of the previous "not supported in hooks" error.
Wiring reading the composite functions files will be added in follow-up PRs in the stack.
# Test Plan
Added unit tests.
# Why
For a step with no `if:`, whether the step should run was decided in 3 separate places: `BuildStep.shouldExecuteStep`, the composite function scope (same rule), and the hook executor (its own rule). That bypass means composite scopes never see hook defaults, which is a blocker for adding support for composite functions in hooks.
# How
A single gate now decides whether any step runs, taking a single input: a bool telling whether a step with no `if:` should run. Composite functions called from hooks therefore inherit the hook's rule. Steps with an explicit `if:` are unaffected.
Behavior-preserving refactor.
# Test Plan
- Existing steps/hook tests still pass.
- Added unit coverage for the run-by-default value on `shouldExecuteStep` /
`isActive`, and hook sibling skip/continue cases for the before/after defaults.
# Why
This PR stack adds local composite functions for EAS workflows (`uses: ./.eas/functions/...`). Earlier PRs define the schema, expand calls into steps, and wire inputs/outputs. The build runtime still needs to load those `function.yml` files from the project and pass them into `StepsConfigParser`.
This PR is the I/O layer: discover referenced local composite functions on disk, validate them, and hand the catalog to the parser for custom builds and generic jobs.
# How
- Adds catalog helpers in `@expo/steps` (`buildCompositeFunctionCatalogFromStepsAsync`, `resolveLocalCompositeFunctionPath`)
- Adds `packages/build-tools/src/steps/compositeFunctions.ts` to resolve paths relative to the EAS project root, read `function.yml` / `function.yaml`, and validate with `CompositeFunctionConfigZ`
- Wires the catalog into `runCustomBuildAsync` and `runGenericJobAsync`
# Test Plan
Added unit tests for catalog loading and custom-build parse integration.
# Why
This PR stack adds local composite functions for EAS workflows. A `function.yml` declares `outputs:` with templated values, and the caller should read them as `${{ steps.setup.outputs.version }}`, where `setup` is the id of the calling step.
After the previous PRs, data flows into a composite function (inputs, env) but nothing flows back out. This PR closes that loop.
# How
For a composite function that declares `outputs:`, `CompositeFunctionExpander` appends a synthetic function step after the inner steps, reusing the caller's step id.
- The step runs with `if: ${{ always() }}`
- Output values are interpolated against the composite-function-local step namespace
# Test Plan
Added outputs unit tests.
# Why
This PR stack adds support for local composite functions in workflows. After structural expansion, inner steps still could not see `${{ inputs.* }}`, and caller `env` did not yet reach them at runtime.
This PR adds the data layer: input declaration, validation and interpolation, and runtime resolution of the caller context (env, templated working directories).
# How
- `CompositeFunctionExpander` builds declared composite function inputs as real `BuildStepInput` instances
- `BuildStepCompositeFunctionScope` exposes `${{ inputs.* }}` as lazy getters
- Caller `env` and working directory templating resolve through the composite function scope
# Test Plan
Added inputs and scoping unit tests.
# Why
EAS workflows need reusable local composite functions: a step like `uses: ./.eas/functions/setup` should run the steps defined in `function.yml`, not be treated as a built-in function.
This PR adds the structural layer for that: turning a composite function call into concrete workflow steps with correct ids, scoping, and control flow. Input interpolation, outputs, and loading `function.yml` from disk are handled in separate PRs.
# How
When `StepsConfigParser` sees a local `uses:` path (`./` or `../`), `CompositeFunctionExpander` replaces the call with a flat list of inner steps:
- ID namespacing: inner step `read` under caller `setup` becomes `setup__read`
- Each expanded step carries a `BuildStepCompositeFunctionScope` so `${{ steps.* }}` and `${{ inputs.* }}` resolve against composite-function-local names
- Nested local composite functions are expanded recursively with cycle and depth checks
- Local composite functions are rejected in hooks
# Test Plan
Added expansion unit tests covering nesting, cycles, depth limits, and id collisions.
# Why
Local composite functions use `uses: ./...` paths. Custom build configs (`.eas/build/*.yml`) must reject these early with a clear error.
# How
- Adds `isCompositeFunctionPath` in `localCompositeFunctions.ts`
- Rejects local composite function paths in `validateAllFunctionsExist` for custom builds
# Test Plan
Added unit tests.