# Set Up Renovate for a Temporal TypeScript Monorepo

Yes. An agent reads your Temporal monorepo's workspace, shared lockfile and pinned actions, writes a Renovate config grouping the SDK packages, and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/add-renovate/temporal/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent starts with the shape of the repository, because that is what makes Dependabot a poor fit and Renovate a good one. In a repository like temporalio/samples-typescript, `pnpm-workspace.yaml` lists `*`, `message-passing/*`, `polling/*`, `openai-agents/*` and the `food-delivery` and `monorepo-folders` packages as workspace members, with `sharedWorkspaceLockfile: true` and `hoist: false`, so one `pnpm-lock.yaml` at the root covers every sample, and `.scripts/list-of-samples.json` names sixty-three of them. Each sample has its own `package.json` with `@temporalio/activity`, `@temporalio/client`, `@temporalio/worker`, `@temporalio/workflow` and `@temporalio/envconfig` at the same `^1.24.0` range plus its own `devDependencies`. There is no `renovate.json` and no `.github/dependabot.yml`.

It then reads how the SDK is upgraded today. `.scripts/upgrade-versions.mjs`, run as `pnpm upgrade-versions <version>`, walks every `package.json` with `glob` and rewrites every `@temporalio/*` entry in `dependencies`, `devDependencies` and `resolutions` to one version, which tells the agent that the SDK packages are meant to move together, across all samples, in one change. `.github/workflows/ci.yml` pins its actions to commit SHAs with a version comment (`actions/checkout@9c091bb… # v7.0.0`, `pnpm/action-setup@fc06bc1… # v5`, `actions/setup-node@53b8394… # v6`) and tests a Node matrix of 20, 22 and 24. The root `package.json` has `pnpm.packageExtensions` for `eslint-config-next`, `mocha` and `@temporalio/strands-agents`, and `.github/CODEOWNERS` gives `pnpm-lock.yaml` its own owners.

The configuration follows from that. `renovate.json` extends `config:recommended`, sets `rangeStrategy: bump` so the caret ranges in each `package.json` move with the lockfile, and has four `packageRules`: a `temporal-sdk` group that puts every `@temporalio/*` package across all samples into one pull request, matching what `upgrade-versions.mjs` does by hand; a weekly group for the shared tooling (`typescript`, `ts-node`, `mocha`, `eslint`, `prettier` and their types) so sixty-three samples do not each open a pull request for the same `@types/node` patch; a monthly group for everything else; and a rule that leaves the `ai-sdk`, `openai-agents`, `google-adk-agents` and `strands-agents` samples' model-provider packages to their own pull requests, since `CODEOWNERS` routes those directories to another team. `lockFileMaintenance` is enabled on a schedule so the shared lockfile gets a clean refresh, the `github-actions` manager keeps the SHA pins and rewrites the version comments, and `prConcurrentLimit` keeps the first week readable.

The proof is a dry run of Renovate itself. In the sandbox the agent runs `pnpm install --frozen-lockfile` on Node 22 to show the lockfile is consistent, validates the file with `renovate-config-validator`, then runs `renovate --platform=local`, which reads the checkout as a repository without any token, lists every dependency it extracted from the sixty-three manifests and the workflow, and prints the updates it would open and how the rules group them. That output is what the pull request description quotes, so a reviewer sees the first pull requests before any are opened.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Set up Renovate for this Temporal TypeScript monorepo. Read pnpm-workspace.yaml, the root package.json, .scripts/upgrade-versions.mjs, .scripts/list-of-samples.json, .github/CODEOWNERS and .github/workflows/ci.yml first, and note that one shared pnpm lockfile covers every sample, that an existing script bumps every @temporalio package to one version across all manifests, and that the workflow pins actions to commit SHAs with version comments. Write renovate.json extending config:recommended with rangeStrategy bump, a group that moves every @temporalio package across all samples in one pull request, a weekly group for shared tooling such as typescript, ts-node, mocha, eslint and prettier, a monthly group for the rest, a rule that keeps the model-provider packages in the AI samples separate because CODEOWNERS routes those directories elsewhere, lockFileMaintenance on a schedule, the github-actions manager, and a concurrent pull request limit. Run pnpm install --frozen-lockfile on the Node version in .nvmrc, validate the config with renovate-config-validator, run renovate with --platform=local as a dry run and include its detected dependencies and planned updates in the pull request description. Open a pull request.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

What comes back is a pull request on its own branch adding `renovate.json` and nothing else: no dependency is bumped and no sample is touched. The file is short enough to read in one screen, with a comment-free structure the validator accepts and a `$schema` line so editors check it.

The description walks through each `packageRules` entry with the reason it exists, quotes the validator result, the frozen install, and the dry run's list of detected dependencies and planned pull requests grouped by rule, so the reviewer can see that the `@temporalio/*` group would open one pull request and the tooling group another. The transcript at `GET /o/{org}/sessions/{id}/messages` keeps the full dry-run log.

Before merging, a reviewer checks the dry run against expectations: that the SDK group covers every sample, that the AI samples' provider packages appear in their own entries, and that the Node matrix in `ci.yml` is left alone. After the merge, the Renovate app opens its onboarding pull request against the committed config, and the first real pull requests follow the groups the dry run predicted.

## Run it on every Monday morning

Renovate opens the pull requests on its own schedule once the config is merged, so the weekly job here is review, not setup: create an automation in the Project with a `schedule` trigger, a `cron` such as `0 8 * * 1` in your `timezone`, and a prompt that reads the open Renovate pull requests, runs the affected samples' build and tests in the sandbox, and comments on each with the result. An automation run has its own `max_runs_per_hour` cap.

To run the setup itself across several repositories, send `POST /o/{org}/sessions` with this body and each repository in `resources`, with a `request_id` that is a UUID v5 of the repository name, so a retried call returns the run already started.

## Why run it on Rush?

A monorepo of sixty-odd samples with one lockfile breaks the per-package model of most update bots: without grouping, a single `@types/node` release becomes dozens of pull requests, and the SDK packages, which the maintainers already bump together with a script, would arrive as separate changes that fail together. Writing the rules that avoid this means reading the workspace, the script, the code owners and the workflow first, which is slow by hand and routine for an agent.

The dry run is the part that makes the pull request reviewable: Renovate's own `--platform=local` output shows exactly which pull requests the config will produce before any is opened. Running it on Rush gives the job a sandbox with the repository's Node version and the whole log kept, and the same body can be sent for every repository the team maintains.

## Frequently asked questions

### Why Renovate rather than Dependabot here?

Because of grouping across manifests. The repository has sixty-three `package.json` files sharing one lockfile, and the SDK packages are meant to move together, which `upgrade-versions.mjs` already encodes. Renovate's `packageRules` can put every `@temporalio/*` dependency from every sample into one pull request and handle SHA-pinned actions with version comments; Dependabot groups within a directory and would open far more pull requests.

### Does it replace the upgrade-versions script?

No. The script stays for the day an SDK release should be rolled out by hand or pointed at a local `file:` build, which Renovate cannot do. The Renovate group covers the routine case, a new SDK release on npm, with the same result: every sample on one version in one pull request.

### Will it bump the Node versions in the CI matrix?

No. The matrix in `ci.yml` is a list of major versions the samples are meant to support, not a dependency, and the config does not touch it. The `github-actions` manager updates the action SHAs and their version comments only.

### How does the dry run work without a GitHub token?

Renovate's `--platform=local` mode reads the current directory as the repository and makes no API calls to a code host. It still fetches package metadata from npm to find newer versions, so the sandbox needs network access, which it has, and it prints the dependencies it found and the updates it would open as a log rather than opening anything.

## More Temporal jobs

- [Add Replay Tests to Temporal Workflows](https://getrush.ai/run/add-replay-tests/temporal/)
- [Add Activity Retry Policies to a Temporal TypeScript Workflow](https://getrush.ai/run/add-retry-policies/temporal/)
- [Add a Temporal Schedule to a TypeScript Workflow](https://getrush.ai/run/add-schedules/temporal/)

## The same job on other stacks

- [Add Renovate to a Terraform Module Repository](https://getrush.ai/run/add-renovate/terraform/)
- [Set Up Renovate for an Ansible Role](https://getrush.ai/run/add-renovate/ansible/)
- [Add Renovate to Keep Docker Compose Image Tags Current](https://getrush.ai/run/add-renovate/docker-compose/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
