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.
* [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
* [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.
## Summary
- remove `buildStepInternalId` emission from `BuildStep`
- stop generating the extra UUID entirely
- drop the now-unused field from local build log sanitization
Just want to make logs smaller.
## Testing
- yarn --cwd packages/steps test --runInBand BuildStep-test.ts
- yarn --cwd packages/steps typecheck
<!-- If this PR requires a changelog entry, add it by commenting the PR with the command `/changelog-entry [breaking-change|new-feature|bug-fix|chore] [message]`. -->
<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
# Why
We're moving to Oxc in universe too. The toolset is faster than ESLint / Prettier.
# How
Asked Codex to migrate the repository. I don't think all rules got migrated, unfortunately, but also the lint are in a bit weird state (different rules in `eas-cli` vs the rest of the repo). I hope we can unify the rules soon.
# Test Plan
CI should pass.
## Consolidate eas-build packages into eas-cli monorepo
This PR completes the migration of packages from the `eas-build` repository into `eas-cli`, consolidating all EAS Build tooling into a single monorepo.
### Background
Previously, the EAS Build libraries lived in a separate `expo/eas-build` repository. This made development and releases more complex, requiring coordination between two repos. By consolidating into `eas-cli`, we can:
- Develop and test changes across CLI and build tools in a single PR
- Simplify the release process
- Reduce dependency version drift between packages
### Migrated Packages
The following packages have been moved from `eas-build`:
| Package | npm Name | License |
|---------|----------|---------|
| `build-tools` | `@expo/build-tools` | BUSL-1.1 |
| `eas-build-job` | `@expo/eas-build-job` | MIT |
| `steps` | `@expo/steps` | BUSL-1.1 |
| `logger` | `@expo/logger` | BUSL-1.1 |
| `downloader` | `@expo/downloader` | BUSL-1.1 |
| `turtle-spawn` | `@expo/turtle-spawn` | BUSL-1.1 |
| `template-file` | `@expo/template-file` | BUSL-1.1 |
| `local-build-plugin` | `eas-cli-local-build-plugin` | BUSL-1.1 |
| `create-eas-build-function` | `create-eas-build-function` | MIT |
### Changes
**Package Configuration:**
- Updated `repository` and `bugs` URLs in all migrated package.json files to point to `expo/eas-cli`
- Updated README repository links
- Aligned dependency versions across `eas-cli`, `eas-json`, and `worker` to use workspace packages
**Documentation:**
- Expanded `CLAUDE.md` with comprehensive documentation covering all packages, architectural patterns, and development workflows
- Added `AGENTS.md` for AI agent guidance
**Licensing:**
- Added `LICENSE-BUSL` for BUSL-1.1 licensed packages
- Added `LICENSE-eas-build-job` for MIT licensed packages
**Build Infrastructure:**
- Added `.gitignore` entries for build artifacts: `dist`, `*.tsbuildinfo` (needed for `tsconfig.json` and `tsconfig.build.json`), vim swap files
- Added `bin/eas-cli-local-build-plugin` symlink for local build testing
**Dependency Cleanup:**
- Removed stale npm registry entries from `yarn.lock` - workspace packages now resolve locally
### Testing
- [x] `yarn install` completes successfully
- [x] `yarn build` builds all packages
- [x] `yarn test` passes
- [x] Worker builds and runs correctly against workspace packages
### Follow-up
After this PR is merged:
- Archive or deprecate the `expo/eas-build` repository
- Update any CI/CD pipelines that referenced the old repo
- Update internal documentation pointing to eas-build