gemini-cli

Gemini CLI Releases

Release Cadence and Tags

We will follow https://semver.org/ as closely as possible but will call out when or if we have to deviate from it. Our weekly releases will be minor version increments and any bug or hotfixes btween releases will go out as patch versions on the most recent release.

Preview

New preview releases will be published each week at UTC 2359 on Tuesdays. These releases will not have been fully vetted and may contain regressions or other outstanding issues. Please help us test and install with preview tag.

npm install -g @google/gemini-cli@preview

Stable

npm install -g @google/gemini-cli@latest

Nightly

npm install -g @google/gemini-cli@nightly

Release Process.

Where x.y.z is the next version to be released. In most all cases for the weekly release this will be an increment on y, aka minor version update. Major version updates x will need broader coordination and communication. For patches z see below. When possible we will do our best to adher to https://semver.org/

Our release cadence is new releases are sent to a preview channel for a week and then promoted to stable after a week. Version numbers will follow SemVer with weekly releases incrementing the minor version. Patches and bug fixes to both preview and stable releases will increment the patch version.

Nightly Release

Each night at UTC 0000 we will auto deploy a nightly release from main. This will be a version of the next production release, x.y.z, with the nightly tag.

Create Preview Release

Each Tuesday at UTC 2359 we will auto deploy a preview release of the next production release x.y.z.

Promote Stable Release

After one week (On the following Tuesday) with all signals a go, we will manually release at 2000 UTC via the current on-call person.

Patching Releases

If a critical bug needs to be fixed before the next scheduled release, follow this process to create a patch.

1. Create a Hotfix Branch

First, create a new branch for your fix. The source for this branch depends on whether you are patching a stable or a preview release.

2. Implement the Fix

In your new hotfix branch, either create a new commit with the fix or cherry-pick an existing commit from the main branch. Merge your changes into the source of the hotfix branch (ex. https://github.com/google-gemini/gemini-cli/pull/6850).

3. Perform the Release

Follow the manual release process using the “Release” GitHub Actions workflow.

How to run a release

4. Update Versions

After the hotfix is released, merge the changes back to the appropriate branch.

Release Schedule

Date Stable UTC 2000 Preview UTC 2359
Aug 19th, 2025 N/A 0.2.0-preview.0
Aug 26th, 2025 0.2.0 0.3.0-preview.0
Sep 2nd, 2025 0.3.0 0.4.0-preview.0
Sep 9th, 2025 0.4.0 0.5.0-preview.0
Sep 16th, 2025 0.5.0 0.6.0-preview.0
Sep 23rd, 2025 0.6.0 0.7.0-preview.0

How To Release

Releases are managed through the release.yml GitHub Actions workflow. To perform a manual release for a patch or hotfix:

  1. Navigate to the Actions tab of the repository.
  2. Select the Release workflow from the list.
  3. Click the Run workflow dropdown button.
  4. Fill in the required inputs:
    • Version: The exact version to release (e.g., v0.2.1).
    • Ref: The branch or commit SHA to release from (defaults to main).
    • Dry Run: Leave as true to test the workflow without publishing, or set to false to perform a live release.
  5. Click Run workflow.

TLDR

Each release, wether automated or manual performs the following steps:

  1. Checks out the latest code from the main branch.
  2. Installs all dependencies.
  3. Runs the full suite of preflight checks and integration tests.
  4. If all tests succeed, it calculates the next version number based on the inputs.
  5. It creates a branch name release/${VERSION}.
  6. It creates a tag name v${VERSION}.
  7. It then builds and publishes the packages to npm with the provided version number.
  8. Finally, it creates a GitHub Release for the version.

Failure Handling

If any step in the workflow fails, it will automatically create a new issue in the repository with the labels bug and release-failure. The issue will contain a link to the failed workflow run for easy debugging.

Docker

We also run a Google cloud build called release-docker.yml. Which publishes the sandbox docker to match your release. This will also be moved to GH and combined with the main release file once service account permissions are sorted out.

Release Validation

After pushing a new release smoke testing should be performed to ensure that the packages are working as expected. This can be done by installing the packages locally and running a set of tests to ensure that they are functioning correctly.

Local Testing and Validation: Changes to the Packaging and Publishing Process

If you need to test the release process without actually publishing to NPM or creating a public GitHub release, you can trigger the workflow manually from the GitHub UI.

  1. Go to the Actions tab of the repository.
  2. Click on the “Run workflow” dropdown.
  3. Leave the dry_run option checked (true).
  4. Click the “Run workflow” button.

This will run the entire release process but will skip the npm publish and gh release create steps. You can inspect the workflow logs to ensure everything is working as expected.

It is crucial to test any changes to the packaging and publishing process locally before committing them. This ensures that the packages will be published correctly and that they will work as expected when installed by a user.

To validate your changes, you can perform a dry run of the publishing process. This will simulate the publishing process without actually publishing the packages to the npm registry.

npm_package_version=9.9.9 SANDBOX_IMAGE_REGISTRY="registry" SANDBOX_IMAGE_NAME="thename" npm run publish:npm --dry-run

This command will do the following:

  1. Build all the packages.
  2. Run all the prepublish scripts.
  3. Create the package tarballs that would be published to npm.
  4. Print a summary of the packages that would be published.

You can then inspect the generated tarballs to ensure that they contain the correct files and that the package.json files have been updated correctly. The tarballs will be created in the root of each package’s directory (e.g., packages/cli/google-gemini-cli-0.1.6.tgz).

By performing a dry run, you can be confident that your changes to the packaging process are correct and that the packages will be published successfully.

Release Deep Dive

The main goal of the release process is to take the source code from the packages/ directory, build it, and assemble a clean, self-contained package in a temporary bundle directory at the root of the project. This bundle directory is what actually gets published to NPM.

Here are the key stages:

Stage 1: Pre-Release Sanity Checks and Versioning

Stage 2: Building the Source Code

Stage 3: Assembling the Final Publishable Package

This is the most critical stage where files are moved and transformed into their final state for publishing. A temporary bundle folder is created at the project root to house the final package contents.

  1. The package.json is Transformed:
    • What happens: The package.json from packages/cli/ is read, modified, and written into the root bundle/ directory.
    • File movement: packages/cli/package.json -> (in-memory transformation) -> bundle/package.json
    • Why: The final package.json must be different from the one used in development. Key changes include:
      • Removing devDependencies.
      • Removing workspace-specific “dependencies”: { “@gemini-cli/core”: “workspace:*” } and ensuring the core code is bundled directly into the final JavaScript file.
      • Ensuring the bin, main, and files fields point to the correct locations within the final package structure.
  2. The JavaScript Bundle is Created:
    • What happens: The built JavaScript from both packages/core/dist and packages/cli/dist are bundled into a single, executable JavaScript file.
    • File movement: packages/cli/dist/index.js + packages/core/dist/index.js -> (bundled by esbuild) -> bundle/gemini.js (or a similar name).
    • Why: This creates a single, optimized file that contains all the necessary application code. It simplifies the package by removing the need for the core package to be a separate dependency on NPM, as its code is now included directly.
  3. Static and Supporting Files are Copied:
    • What happens: Essential files that are not part of the source code but are required for the package to work correctly or be well-described are copied into the bundle directory.
    • File movement:
      • README.md -> bundle/README.md
      • LICENSE -> bundle/LICENSE
      • packages/cli/src/utils/*.sb (sandbox profiles) -> bundle/
    • Why:
      • The README.md and LICENSE are standard files that should be included in any NPM package.
      • The sandbox profiles (.sb files) are critical runtime assets required for the CLI’s sandboxing feature to function. They must be located next to the final executable.

Stage 4: Publishing to NPM

Summary of File Flow

graph TD
    subgraph "Source Files"
        A["packages/core/src/*.ts<br/>packages/cli/src/*.ts"]
        B["packages/cli/package.json"]
        C["README.md<br/>LICENSE<br/>packages/cli/src/utils/*.sb"]
    end

    subgraph "Process"
        D(Build)
        E(Transform)
        F(Assemble)
        G(Publish)
    end

    subgraph "Artifacts"
        H["Bundled JS"]
        I["Final package.json"]
        J["bundle/"]
    end

    subgraph "Destination"
        K["NPM Registry"]
    end

    A --> D --> H
    B --> E --> I
    C --> F
    H --> F
    I --> F
    F --> J
    J --> G --> K

This process ensures that the final published artifact is a purpose-built, clean, and efficient representation of the project, rather than a direct copy of the development workspace.

This site is open source. Improve this page.