Avvia Native Build dalla UI della CI

Copia un prompt di configurazione con i passaggi di installazione e la guida markdown completa per questo plugin.

A volte serve un binario iOS o Android firmato senza dover approvare una PR o creare un tag di release — un build per QA, un nuovo invio agli store o un TestFlight una tantum. Ogni principale host code può avviare una pipeline dalla propria web UI. Questa guida spiega come collegare l'interfaccia a Capgo Build.

Cosa ottieni

Niente cerimonie Git

Clicca su Run workflow / Run pipeline. Capgo Build compila direttamente dal branch che selezioni.

Input sicuri

Piattaforma e modalità di build utilizzano opzioni predefinite dove l'host lo supporta (GitHub / Bitbucket / Azure). Le variabili GitLab rimangono modificabili per ogni esecuzione, a meno che non definisci input della pipeline con options.

Stessi Secret della CI

Riutilizza le credenziali di Capgo Build già presenti nel tuo repo. Nessuna configurazione extra sui laptop.

Prerequisiti

Capgo Build funziona sia localmente che in CI — vedi Per iniziare
Secret di firma già presenti nell'host (per GitHub, esporta con CLI e gh secret set -f)
CAPGO_TOKEN salvati come secret mascherati / variabili CI

Azioni GitHub

di GitHub Azioni la tab può avviare qualsiasi workflow che dichiara workflow_dispatch.

1. Aggiungi il workflow

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. Avvialo dalla UI

Apri il repository GitHub nel browser
Vai su Azioni
Seleziona Build di Capgo (Manuale)
Clicca su Esegui workflow
Seleziona branch, piattaforma e modalità
Verifica Esegui workflow

Chiunque abbia write può avviare una build. L'esempio mappa release l'esecuzione su un ambiente GitHub chiamato production — crea l'ambiente e aggiungi i reviewer per approvare le build. Senza environment: sul job, le regole di protezione dell'ambiente non si applicano.

GitLab CI

GitLab può eseguire un job da Build → Pipelines → Esegui pipeline quando il job è disponibile per quel branch.

# 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

Apri il progetto GitLab
Vai su Build → Pipelines → Esegui pipeline
Seleziona il branch
Facoltativamente imposta PLATFORM / BUILD_MODE le variabili per questa esecuzione
Avvia la pipeline, quindi clicca sul pulsante play su capgo_native_manual

when: manual evita che il job parta a ogni push; la web UI (o un token di trigger della pipeline) la avvia on demand.

Bitbucket Pipelines

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

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"

Eseguila da Pipeline → Esegui pipeline → Custom: capgo-native-build. Salva CAPGO_TOKEN e i file di firma sotto Impostazioni repository → Pipelines → Variabili del repository.

Azure DevOps

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 e pr: none disabilita la pipeline dagli automatic run di CI/PR, così potrai avviarla da Pipeline → Esegui pipeline (o tramite webhook). Se il progetto usa Azure Repos branch policies che mettono in coda questa pipeline, disabilita quella policy separatamente. Aggiungi CAPGO_TOKEN e i valori di signing a un variable group contrassegnato come secret.

Input consigliati

Input	Valori suggeriti	Note
Piattaforma	`ios`, `android`, `both`	Matrix quando `both`
Modalità	`debug`, `release`	Debug + `--output-upload` per link QA
distribuzione iOS	`app_store`, `ad_hoc`	Ad-hoc non invia all'App Store

Per artefatti QA scaricabili, combina debug Android con --no-playstore-upload --output-upload e leggi l'URL con build last-output.

Note di sicurezza

Preferisci regole di protezione ambiente (GitHub) o variabili protette (GitLab) per release build che inviano agli store.
Non inserire password di firma nei workflow inputs — usa solo secrets o variabili.
Limita chi può eseguire i workflow tramite i ruoli del repository e i permessi del team (è richiesto l'accesso in scrittura su GitHub). La branch protection da sola non controlla Esegui workflow; aggiungi un controllo di autorizzazione nel workflow se solo un gruppo ristretto può avviare i build.

Azioni GitHub (configurazione completa) Esporta le credenziali e push/tagga i workflow.

Auto OTA o Native Lascia che la CI scelga tra live update e Capgo Build ad ogni push.

Trigger tramite Webhook Esegui le stesse pipeline da una dashboard admin tramite HTTP.