[!NOTE] There are parts of this release process that can only be completed by Googlers on the Dash team. If you are not a Googler on the Dash team, please reach out on the #hackers-devtools Discord channel before trying to create a DevTools release.

DevTools release process

A diagram of the DevTools release process

A new minor version of DevTools should be released into the Dart SDK monthly. This release should be timed with the Dart / Flutter release code cutoff dates so that we can ensure it is included with the next Flutter beta (see the Dash release schedule). The minor DevTools releases must be submitted to the Dart SDK before the Beta release cutoff date. Dev or patch releases of DevTools may occur as needed between minor or major releases.

Before each minor or major DevTools release, the DevTools team will perform a bug bash for quality assurance and to prevent regressions from slipping into the release.

Pre-requisites

Ensure that you have access to dt by adding the tool/bin folder to your PATH environment variable

MacOS Users
- add the following to your ~/.bashrc file.
- export PATH=$PATH:<DEVTOOLS_DIR>/tool/bin
  [!NOTE]
  Replace <DEVTOOLS_DIR> with the local path to your DevTools repo path.
Windows Users
- Open “Edit environment variables for your account” from Control Panel
- Locate the Path variable and click Edit
- Click the New button and paste in <DEVTOOLS_DIR>/tool/bin
  [!NOTE]
  Replace <DEVTOOLS_DIR> with the local path to your DevTools repo path.

Ensure your Dart SDK is configured:
1. You have a local checkout of the Dart SDK (for getting started instructions, see sdk/CONTRIBUTING.md).
2. Ensure your .bashrc sets $LOCAL_DART_SDK
```
DART_SDK_REPO_DIR=<Path to cloned dart sdk>
export LOCAL_DART_SDK=$DART_SDK_REPO_DIR/sdk
```
Ensure you have goma configured

How to release Dart DevTools

Release into the Dart SDK master branch
- Full release (monthly cadence with the Dart / Flutter beta release schedule)
- Dev release (as needed)
Cherry-pick releases into the Dart SDK stable / beta branches

Full release into the Dart SDK master branch

1) Configure/Refresh environment

Make sure:

Your Dart SDK checkout is on the latest main branch:
```
git checkout main; git rebase-update
```
Your Flutter SDK checkout is on the latest commit in specified in DevTools:
```
dt update-flutter-sdk --update-on-path
```

2) Prepare the release

2.1) Create a release PR

[!NOTE] If you need to install the Github CLI you can run: brew install gh

From the devtools/tool directory, run the following:

dt release-helper

This command will automatically:

create a new branch using the tip of master and check out locally
create a PR for release changes

The following is required until https://github.com/flutter/devtools/issues/7939 is fixed:

Update the flutter-candidate.txt to the latest Flutter candidate SHA in g3 (see instructions in DevTools Release Rotation email).
This change should get committed with the DevTools release PR so that we know which version it was released with.

[!NOTE]
If there are failures caused by the latest Flutter SHA, this step can be skipped.

git commit -am "Update to latest Flutter candidate"
git push upstream <release-branch>

Finally, update your Flutter to the commit you just spcified.

dt update-flutter-sdk --update-on-path

2.2) Verify the version changes for the Release PR

Verify the changes in the release PR contain:

an updated the devtools_app pubspec version
an updated version constant in packages/devtools_app/lib/devtools.dart

The other DevTools packages each have their own versioning strategy and are published as needed on their own schedules. For devtools_app_shared, devtools_extensions, and devtools_shared, we adhere to semantic versioning where breaking changes should be versioned with a major version bump, and all other changes should be minor or patch version bumps.

3) Test the release PR

Build DevTools in release mode and serve it from a locally running DevTools server instance:
```
dt serve
```
Launch DevTools and verify that everything generally works.
- open the page in a browser (http://localhost:53432)
- flutter run an application
- connect to the running app from DevTools
- verify:
  - pages generally work
  - there are no exceptions in the chrome devtools log
- If you find any release blocking issues:
  - fix them before releasing.
  - Then grab the latest commit hash that includes
    - the release prep commit
    - the bug fixes,
  - use this commit hash for the following steps.
Once the build is in good shape,
- revert any local changes.
```
git checkout . && \
git clean -f -d;
```

4) Submit the Release PR

Receive an LGTM for the PR, squash and commit.

5) Wait for the binary to be uploaded CIPD

On each DevTools commit, DevTools is built and uploaded to CIPD. You can check the status of the builds on this dashboard. Within minutes, a build should be uploaded for the commit you just merged and tagged.

[!NOTE]
If the CIPD build times out, instructions for re-triggering can be found at go/dart-engprod/release.md

6) Update the DevTools hash in the Dart SDK

Run the tool script with the commit hash you just merged and tagged:

dt update-sdk-deps -c <commit-hash>

This automatically creates a Gerrit CL with the DEPS update for DevTools. Quickly test the build and then add a reviewer:

Build the Dart SDK locally

cd $LOCAL_DART_SDK && \
gclient sync -D && \
./tools/build.py -mrelease -ax64 create_sdk;

Verify that running dart devtools launches the version of DevTools you just released.
- for OSX
```
xcodebuild/ReleaseX64/dart-sdk/bin/dart devtools
```
- For non-OSX
```
out/ReleaseX64/dart-sdk/bin/dart devtools
```
If the version of DevTools you just published to CIPD does not load properly, you may need to hard reload and clear your browser cache.
Add a reviewer and submit once approved.

7) Tag the release

In your terminal from the devtools directory, checkout the commit that you just released into the Dart SDK (the hash you updated the DEPS file with):
```
git fetch upstream; git checkout <release-commit>`
```
Then, tag the release:
```
dt tag-version
```
This command creates a tag on the flutter/devtools repo for this release. The version for the tag is automatically determined from packages/devtools/pubspec.yaml so there is no need to manually enter the version.

8) Verify and Submit the release notes

Follow the instructions outlined in the release notes README.md to add DevTools release notes to Flutter website and test them in DevTools.
Once release notes are submitted to the Flutter website, send an announcement to g/flutter-internal-announce with a link to the new release notes.

9) Prepare DevTools for the next beta release

The daily-dev-bump workflow is currently broken: #8558. Until it's fixed, manually update the DevTools version for the next release and open a PR with the changes:

dt update-version auto --type minor
dt update-version auto --type dev

~~Update the DevTools version for the next release:~~

gh workflow run daily-dev-bump.yaml -f updateType=minor+dev

~~This will kick off a workflow that will automatically create a PR with a minor + dev version bump. That PR should then be auto-submitted.~~

~~Make sure that the release PR goes through without issue:~~
- ~~See the workflow run here~~
- ~~Go to https://github.com/flutter/devtools/pulls to see the pull request that ends up being created~~

Dev release into the Dart SDK master branch

To publish a dev release follow just section Update the DevTools hash in the Dart SDK of the full release process.

Cherry-pick releases

1) Prepare the release in the `flutter/devtools` repo

Find the DevTools tag that you want to perform the cherry-pick release on top of.
For example, if you want to perform a cherry pick release of DevTools into the Flutter / Dart beta branch, you can see what the current version of DevTools is on Flutter / Dart beta by doing the following:
1. Find the latest beta release candidate (or stable release candidate) that you will cherry-pick into.
2. In your terminal, in the flutter/flutter repository, run git checkout <latest-beta-version>.
3. Run flutter --version to see which version of DevTools is on current Flutter / Dart beta (assuming which flutter points to your local Flutter git repository). For example, you might see:
  Tools • Dart 3.8.1 • DevTools 2.45.1
  indicating that DevTools version 2.45.1 is used in this Flutter version.
Checkout that tag in your local DevTools repo. For this example, we'll use v2.29.0 as the base branch and 2.29.1 as the cherry-pick branch.
```
git fetch upstream 
git checkout v2.29.0
```
Create a new branch for your cherry pick release.
```
git checkout -b 2.29.1
```
Cherry pick the commit(s) you want in this cherry-pick release, and bump the DevTools version number:
```
git cherry-pick <commit>
dt update-version auto -t patch
```

Commit your changes and push to the upstream remote.

git add .;
git commit -m "Prepare cherry-pick release - DevTools 2.29.1";
git push upstream 2.29.1

To move on to the next step, you will need to take note of two values:

The name of the DevTools branch you just created (e.g. 2.29.1)
The commit hash that is at the tip of this branch (see https://github.com/flutter/devtools/branches).

2) Manually run the DevTools Builder

Follow the instructions at go/dart-engprod/devtools.md#cherry-picks to trigger the DevTools builder.

3) Create the cherry-pick CL in the Dart SDK

Checkout the Dart SDK branch you want to perform the cherry-pick on top of (e.g. stable or beta), and create a new branch:

git new-branch --upstream origin/<stable or beta> cherry-pick-devtools

From this branch:

Edit the "devtools_rev" entry in the Dart SDK DEPS file to point to the cherry-pick release hash (the commit at the tip of the cherry-pick branch you created above).
[Only if cherry-picking to stable] add a CHANGELOG entry.

Commit your changes and upload your CL:

git add .
git commit -m "Cherry-pick DevTools 2.29.1"
git cl upload -s

Once your CL is uploaded to Gerrit, modify your changelist commit message to meet the cherry-pick requirements.

The CL description should look like this:

[stable or beta] Cherry-pick DevTools <new version number> into the SDK <stable or beta> branch.

Issue description: When attempting to use foo under certain conditions, users are unable to
compile.
What is the fix: foo is now evaluated at runtime.
Why cherry-pick: Users of foo are no longer able to compile to bar.
Risk: Low, this fix has landed on the main channel and is tested on the same infrastructure. 
Issue link(s): https://github.com/dart-lang/sdk/issues/12345678
Cherry-pick: https://github.com/flutter/devtools/compare/<previous DevTools tag>...<new version number>
Change-Id: Id75075a7e697559263742bc25972ef47532c39cb

Then trigger a CQ Dry Run, add reviewers, and wait for approval. DO NOT merge the CL yet.

Do not move on to the next steps unless your cherry-pick CL has been approved and merged.

4) Create a DevTools tag for the cherry-pick release

[!IMPORTANT] If your cherry-pick CL has not been approved and merged, wait.

Once your cherry-pick has been approved and merged, create a tag for this cherry-pick release. This will ensure that we have a tag we can branch from if we need to create another DevTools cherry-pick release from the tip of the one we just created.

Check out the cherry-pick branch you created earlier, and create a git tag:

git checkout upstream/2.29.1
dt tag-version

5) Create the merge commit in the `flutter/devtools` repo