Stallion

CI/CD Integration for React Native OTA Updates — Automate, Test, and Ship

Modern React Native development requires automation. CI/CD pipelines, instant testing, and faster rollouts define high-performance mobile teams. React Native Stallion provides first-class support for CI/CD workflows and a blazing-fast testing system built right into your app.

Automate OTA bundle releases via CI/CD, use GitHub Actions to publish on every main merge, and slash dev-to-QA time using Stallion's version switching UI. React Native Stallion supports popular CI/CD platforms including GitHub Actions, Bitrise, CircleCI, Expo, Jenkins, Appcircle, and Codemagic.

Supported CI/CD Platforms

React Native Stallion seamlessly integrates with all major CI/CD platforms:

GitHub Actions

Automate OTA releases with GitHub Actions workflows. Publish bundles automatically on every push to main.

Bitrise

Native Bitrise integration with dedicated steps for automated CodePush deployments and OTA updates.

CircleCI

CircleCI Orb support for seamless automation of your CI/CD CodePush workflow with React Native Stallion.

Expo

Full Expo integration support for EAS builds and automated OTA update deployments.

Jenkins

Jenkins pipeline integration for enterprise teams requiring on-premise CI/CD automation.

Appcircle & Codemagic

Support for Appcircle and Codemagic CI/CD platforms with automated React Native OTA update workflows.

Automate Releases with CI/CD Integration

React Native Stallion supports CI/CD automation via CI tokens. These tokens are safe for CI pipelines and scoped only for publishing bundles.

Step 1: Generate a CI Token

From your React Native Stallion Console:

  1. Go to Project Settings
  2. Click Access Tokens
  3. Generate a CI Token

Step 2: Use the Token in CLI

npx stallion publish-bundle \
  --upload-path=org-name/project-name/bucket \
  --platform=android \
  --release-note="your release notes" \
  --ci-token="your-ci-token"

GitHub Actions: Auto Publish on Main

Automate OTA bundle publishing on every push to your main branch using GitHub Actions:

name: Publish OTA with Stallion

on:
  push:
    branches:
      - main

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "18"

      - name: Install dependencies
        run: npm ci

      - name: Publish OTA Update with Stallion
        run: |
          COMMIT_MSG=$(git log -1 --pretty=format:"%s")
          echo "Publishing with commit message: $COMMIT_MSG"
          npx stallion publish-bundle \
            --upload-path=my-org/my-project/prod \
            --platform=android \
            --release-note="$COMMIT_MSG" \
            --ci-token="${{ secrets.STALLION_CI_TOKEN }}"

Store your CI token as a GitHub secret named STALLION_CI_TOKEN for secure access in your workflows.

Complete GitHub Actions Workflow

A complete workflow that publishes bundles, extracts hash, releases, and updates rollout configuration:

name: Stallion Release Automation

on:
  push:
    branches:
      - main

jobs:
  release-bundle:
    runs-on: ubuntu-latest

    env:
      PROJECT_ID: 64f5f341a43eb5ccf93548e4
      APP_VERSION: 1.0.1
      RELEASE_NOTE: "Automated CI Release"
      CI_TOKEN: ${{ secrets.STALLION_CI_TOKEN }}
      UPLOAD_PATH: my-org/my-project/my-bucket
      PLATFORM: android

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install Stallion CLI
        run: npm install -g stallion-cli

      - name: Publish Bundle and Extract Hash
        id: publish
        run: |
          echo "Publishing bundle..."
          OUTPUT=$(stallion publish-bundle \
            --upload-path=$UPLOAD_PATH \
            --platform=$PLATFORM \
            --release-note="$RELEASE_NOTE")

          echo "$OUTPUT"

          HASH=$(echo "$OUTPUT" | grep -oE '[a-f0-9]{64}')
          echo "Bundle hash: $HASH"

          echo "BUNDLE_HASH=$HASH" >> $GITHUB_ENV

      - name: Release Bundle
        run: |
          stallion release-bundle \
            --project-id=$PROJECT_ID \
            --hash=$BUNDLE_HASH \
            --app-version=$APP_VERSION \
            --release-note="$RELEASE_NOTE" \
            --ci-token=$CI_TOKEN

      - name: Update Release (optional rollout config)
        run: |
          stallion update-release \
            --project-id=$PROJECT_ID \
            --hash=$BUNDLE_HASH \
            --release-note="$RELEASE_NOTE" \
            --rollout-percent=100 \
            --is-mandatory=true \
            --ci-token=$CI_TOKEN

Stallion CLI Commands for CI/CD

Publishing a Bundle

stallion publish-bundle \
  --upload-path=orgname/project-name/bucket-name \
  --platform=android/ios \
  --release-note="Your release note here"

Promoting a Bundle

stallion release-bundle \
  --project-id=<your_project_id> \
  --hash=<bundle_hash> \
  --app-version=<target_app_version> \
  --release-note="Your release note" \
  --ci-token=<your_ci_token>

Updating a Release

stallion update-release \
  --project-id=<your_project_id> \
  --hash=<bundle_hash> \
  --release-note="Updated release note" \
  --rollout-percent=<percent> \
  --is-mandatory=<true|false> \
  --ci-token=<your_ci_token>

Instant QA with Stallion Testing Framework

Shipping updates is half the battle. Testing them quickly is just as important. Stallion Testing lets your team install any version of the app directly inside the released app using a built-in SDK modal.

No rebuilds. No TestFlight. No APK uploads. Just deploy, tap, and test. Stallion lets you switch between app versions instantly, speeding up QA/dev cycles.

Integrate Stallion Modal

import { useStallionModal } from "react-native-stallion";

const MyDebugScreen = () => {
  const { showModal } = useStallionModal();

  return <Button title="Open Stallion" onPress={showModal} />;
};

Set Up Security Pin

Set a security pin in your React Native Stallion Console to restrict internal tester access. After upload, the build shows up inside the Stallion modal. Anyone can install it by clicking the download button and restarting the app.

Benefits of CI/CD Integration

Automated Releases

Publish OTA updates automatically on every merge to main. No manual intervention required.

Faster QA Cycles

Test builds instantly using Stallion's version switching UI. Slash dev-to-QA time significantly.

Consistent Workflows

Standardize your release process across all platforms and environments with CI/CD automation.

Secure Token Management

CI tokens are scoped only for publishing bundles, ensuring security in your CI/CD pipelines.

Related Resources

Frequently Asked Questions

How do I automate React Native OTA updates with CI/CD?

React Native Stallion lets you automate OTA releases through your existing CI/CD pipeline. Configure a CI token, install the Stallion CLI, and add the publish and release commands to your workflow. You can automatically publish bundles, test releases, and promote updates to production without manual deployment steps.

Does React Native Stallion support GitHub Actions?

Yes. React Native Stallion supports GitHub Actions for automating OTA bundle publishing and release workflows. You can use Stallion CLI commands and CI tokens to publish an OTA update automatically when changes are pushed to your repository. See the GitHub Actions example above for a complete workflow.

Can I use React Native Stallion with Bitrise?

Yes. React Native Stallion integrates with Bitrise workflows using the Stallion CLI and CI tokens. You can automate OTA bundle publishing and release management directly from your Bitrise pipeline. Native Bitrise steps are also available for streamlined integration.

Does Stallion support other CI/CD platforms?

Yes. Stallion can be integrated with CI/CD platforms such as CircleCI, Jenkins, Expo, Appcircle, and Codemagic using the Stallion CLI and CI tokens. The same core workflow can be adapted to your existing deployment pipeline.

How do I secure CI tokens in my CI/CD pipeline?

Store your Stallion CI token as a secret in your CI/CD platform, such as GitHub Secrets or Bitrise Secrets. CI tokens should never be committed to your repository or exposed in build logs. Use scoped tokens where available and rotate them if they are compromised.

What is the Stallion Testing Framework?

The Stallion Testing Framework lets your team install and test different app versions directly inside a released React Native app using a built-in SDK modal. You can validate OTA updates without rebuilding the native app or uploading separate TestFlight or APK builds, helping teams shorten QA cycles before production rollout.