Trigger Native Builds from the CI UI

Sometimes you need a signed iOS or Android binary without merging a PR or cutting a release tag — a QA build, a store resubmit, or a one-off TestFlight. Every major code host can start a pipeline from its web UI. This guide shows how to wire that UI to Capgo Build.

Ce que vous obtenez

Aucune cérémonie Git

Click Run workflow / Run pipeline. Capgo Build compiles from the branch you pick.

Entrées sécurisées

La plateforme et le mode de construction utilisent des choix contraints où l'hôte les supporte (GitHub / Bitbucket / Azure). Les variables GitLab restent éditable par exécution sauf si vous définissez Entrées de pipeline avec options.

Mêmes secrets que CI

Reuse the Capgo Build credentials already in your repo. Nothing new on laptops.

Prerequisites

• Capgo Construisez en local ou en CI une fois — voir Getting Started
• Signez les secrets déjà présents sur l'hôte (pour GitHub exportez avec le CLI et gh secret set -f)
• CAPGO_TOKEN stocké sous forme de secret masqué / variable CI

Actions de GitHub

GitHub’s Actions tab can start any workflow that declares workflow_dispatch.

1. Ajoutez le flux de travail

.github/flux de travail/capgo-build-manuel.yml

name: Capgo Build (Manual)

on:
  workflow_dispatch:
    inputs:
      platform:
        description: Platform to build
        required: true
        default: both
        type: choice
        options: [ios, android, both]
      mode:
        description: Build mode
        required: true
        default: debug
        type: choice
        options: [debug, release]
      ref_note:
        description: Optional note for the run summary
        required: false
        type: string

jobs:
  build:
    runs-on: ubuntu-latest
    environment: ${{ inputs.mode == 'release' && 'production' || 'build-debug' }}
    strategy:
      fail-fast: false
      matrix:
        platform: ${{ fromJSON(inputs.platform == 'both' && '["ios","android"]' || format('["{0}"]', inputs.platform)) }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - run: npm ci
      - run: npm run build
      - run: npx cap sync ${{ matrix.platform }}

      - name: Capgo Build
        env:
          CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
          BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
          P12_PASSWORD: ${{ secrets.P12_PASSWORD }}
          CAPGO_IOS_PROVISIONING_MAP: ${{ secrets.CAPGO_IOS_PROVISIONING_MAP }}
          APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
          APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
          APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
          APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
          ANDROID_KEYSTORE_FILE: ${{ secrets.ANDROID_KEYSTORE_FILE }}
          KEYSTORE_KEY_ALIAS: ${{ secrets.KEYSTORE_KEY_ALIAS }}
          KEYSTORE_KEY_PASSWORD: ${{ secrets.KEYSTORE_KEY_PASSWORD }}
          KEYSTORE_STORE_PASSWORD: ${{ secrets.KEYSTORE_STORE_PASSWORD }}
          PLAY_CONFIG_JSON: ${{ secrets.PLAY_CONFIG_JSON }}
        run: |
          EXTRA=""
          if [ "${{ inputs.mode }}" = "debug" ] && [ "${{ matrix.platform }}" = "android" ]; then
            EXTRA="--no-playstore-upload --output-upload"
          fi
          npx @capgo/cli@latest build request com.example.app \
            --platform ${{ matrix.platform }} \
            --build-mode ${{ inputs.mode }} \
            $EXTRA

2. Exécutez-le depuis l'interface utilisateur

1. Ouvrez le dépôt GitHub dans le navigateur
2. Allez à Actions
3. Sélectionnez Capgo Build (manuel)
4. Cliquez Exécutez le flux de travail
5. Pick the branch, platform, and mode
6. Confirmez Exécutez le flux de travail

Tout le monde avec write access can start a build. The sample maps release exécute vers un environnement GitHub nommé production — créez cet environnement et ajoutez les revendeurs requis afin que les builds attendent l'approbation. Sans environment: on the job, environment protection rules never apply.

Conseil

Prefer the API or another tool to click the button? Use gh workflow run ou voir Déclencher les builds via Webhook pour repository_dispatch.

GitLab CI

GitLab peut exécuter un travail à partir de Construire → Pipelines → Exécuter le pipeline lorsque le travail est disponible pour cette branche.

# Job fragment for .gitlab-ci.yml
stages:
  - build

variables:
  APP_ID: com.example.app
  PLATFORM: android   # override from Run pipeline UI
  BUILD_MODE: debug

capgo_native_manual:
  stage: build
  when: manual
  script:
    - npm ci
    - npm run build
    - npx cap sync "$PLATFORM"
    - |
      npx @capgo/cli@latest build request "$APP_ID" \
        --platform "$PLATFORM" \
        --build-mode "$BUILD_MODE"
  rules:
    # Actions / Pipelines UI → manual play button
    - if: '$CI_PIPELINE_SOURCE == "web"'
      when: manual
    # Pipeline trigger token / webhook → run automatically
    - if: '$CI_PIPELINE_SOURCE == "trigger"'
      when: on_success
    - when: never

1. Ouvrir le projet GitLab
2. Allez à Construire → Pipelines → Exécuter le pipeline
3. Sélectionnez la branche
4. Configurez facultativement PLATFORM / BUILD_MODE variables pour cette exécution
5. Démarrer la pipeline, puis cliquez sur le bouton de lecture. capgo_manuel native

when: manual garde l'emploi de la tâche à chaque push ; l'interface web (ou un jeton de déclencheur de pipeline) le déclenche à la demande.

Bitbucket Pipelines

Use a custom pipeline so the Bitbucket UI can pass variables:

bitbucket-pipelines.yml

pipelines:
  custom:
    capgo-native-build:
      - variables:
          - name: PLATFORM
            default: android
            allowed-values:
              - ios
              - android
          - name: BUILD_MODE
            default: debug
            allowed-values:
              - debug
              - release
      - step:
          name: Capgo Build
          image: node:24
          script:
            - npm ci
            - npm run build
            - npx cap sync "$PLATFORM"
            - npx @capgo/cli@latest build request com.example.app --platform "$PLATFORM" --build-mode "$BUILD_MODE"

Exécutez-le depuis Pipelines → Exécuter la pipeline → Personnalisé : capgo-build-natifEnregistrez CAPGO_TOKEN et les matériaux de signature sous Paramètres de dépôt → Pipelines → Variables de dépôt.

Azure DevOps

azure-pipelines-capgo-manuel.yml

trigger: none   # disable CI push triggers
pr: none        # also disable PR triggers (GitHub/Bitbucket-backed projects)

parameters:
  - name: platform
    displayName: Platform
    type: string
    default: android
    values:
      - ios
      - android
  - name: buildMode
    displayName: Build mode
    type: string
    default: debug
    values:
      - debug
      - release

pool:
  vmImage: ubuntu-latest

steps:
  - task: NodeTool@0
    inputs:
      versionSpec: '24.x'
  - script: |
      npm ci
      npm run build
      npx cap sync ${{ parameters.platform }}
      npx @capgo/cli@latest build request com.example.app \
        --platform ${{ parameters.platform }} \
        --build-mode ${{ parameters.buildMode }}
    env:
      CAPGO_TOKEN: $(CAPGO_TOKEN)
      # map other signing secrets from Library → Variable groups

trigger: none et pr: none keep the pipeline off automatic CI/PR runs so it starts from Pipelines → Exécuter la pipeline Si le projet utilise des politiques de branchement Azure Repos qui déclenchent cette pipeline, désactivez cette politique séparément. Ajoutez CAPGO_TOKEN et les valeurs de signature à un groupe de variables marqué secret.

Entrées recommandées

Entrée	Valeurs suggérées	Remarques
Plateforme	ios, android, both	Matrice lorsque both
Mode	debug, release	Debug + --output-upload pour liens QA
Distribution iOS	app_store, ad_hoc	Jamais soumis à l'App Store

Pour les artefacts QA téléchargeables, combinez le débogage Android avec --no-playstore-upload --output-upload et lisez l'URL avec build last-output.

Remarques de sécurité

• Préférez les règles de protection de l'environnement (GitHub) ou les variables protégées (GitLab) pour release les builds qui sont soumis aux magasins.
• Do not put signing passwords in workflow inputs seulement dans les secrets/variables.
• Restreignez l'accès aux workflows en fonction des rôles de repository et des permissions d'équipe (un accès écrit est requis sur GitHub). La protection de branch ne contrôle pas seul. Démarrez le workflow; add an in-workflow authorization check if only a narrower group may start builds.

Guides connexes

Actions GitHub (configuration complète) Export credentials and push/tag workflows.

Auto OTA ou Native Laissez CI choisir live update vs Capgo Construire à chaque push.

Déclencher via Webhook Call the same pipelines from an admin dashboard over HTTP.