Automate Capgo Aggiornamenti in tempo reale da Lovable con GitHub Azioni

Il tuo cliente vuole un singolo pulsante in Lovable che invia le modifiche a ogni utente attivo. Hai già dimostrato che il percorso di aggiornamento funziona manualmente:

npx @capgo/cli@latest bundle upload --channel=production

La parte mancante non è un altro comando del terminale all'interno di Lovable. Lovable non può eseguire Capgo durante la pubblicazione. Quando l'aggiornamento in tempo reale GitHub è abilitato, Pubblica le modifiche nel tuo repository. GitHub Azioni esegue la compilazione e bundle upload per te.

Questa guida copre solo la configurazione manuale che il tuo client deve eseguire una volta: aggiungere CAPGO_TOKEN come un segreto GitHub.

Tutto il resto può essere aggiunto con un promemoria Lovable o un piccolo file di workflow.

Nessun SSH, nessun CLI locale, nessun clic extra dopo che la chiave segreta è configurata.

Requisiti

• Progetto Amabile collegato a GitHub (guida all'esportazione)
• Capacitor + @capgo/capacitor-updater nel repository (Guida amabile per mobile)
• L'app è registrata in Capgo con capacitor.config.ts che punta al canale corretto appId
• production Il canale esiste e è collegato alle build che i tuoi utenti eseguono

Passo 1 — Crea una Capgo API chiave

1. Apri console.capgo.app/apikeys/
2. Crea una API chiave con le autorizzazioni per caricare i bundle per l'app
3. Copia la chiave una volta. Non vedrai il valore completo di nuovo

Tratta questa chiave come una password. Non commetterla mai in Git o incollarla nel chat di Lovable.

Passo 2 — Aggiungi CAPGO_TOKEN In GitHub (l'unico passo di ambiente)

Questo è il passo che invii a Kuldeep e a ogni cliente che possiede il repository.

1. Apre il repository GitHub che Lovable sincronizza.
2. Vai a Impostazioni → Segreti e variabili → Azioni
3. Clicca Nuovo segreto repository
4. Nome: CAPGO_TOKEN
5. Inserisci il valore: incolla la Capgo API chiave da Step 1
6. Salva

GitHub inserisce il segreto nei flussi di lavoro come ${{ secrets.CAPGO_TOKEN }}. Il flusso di lavoro sotto legge come variabile di ambiente per il __CAPGO_KEEP_0__ __CAPGO_KEEP_1__. CAPGO_TOKEN environment variable for the Capgo CLI.

loro repository. Hai bisogno solo della chiave in __CAPGO_KEEP_0__, non nei impostazioni di Lovable. Passo 3 — Aggiungi il GitHub workflow di Actions

Step 3 — Add the GitHub Actions workflow

Incolla questo nella chat di Lovable (adatta il nome della branch se il tuo default non è

Lovable aggiungerà il YAML e lo sposterà nella prossima pubblicazione. main):

Create `.github/workflows/capgo-live-updates.yml` that runs on every push to `main`:

1. Checkout code
2. Setup Node.js 24 with npm cache
3. Run `npm ci` and `npm run build`
4. Run `npx @capgo/cli@latest bundle upload --channel=production`
5. Use environment variable `CAPGO_TOKEN` from GitHub Actions secrets (do not hardcode the API key)

Use `actions/checkout@v6` and `actions/setup-node@v6`. Commit the workflow file to the repo.

Opzione B — Aggiungi il file da solo

Crea

__CAPGO_KEEP_0__ .github/workflows/capgo-live-updates.yml:

name: Capgo Live Updates

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: '24'
          cache: 'npm'

      - name: Install and build
        run: |
          npm ci
          npm run build

      - name: Upload bundle to Capgo
        run: npx @capgo/cli@latest bundle upload --channel=production
        env:
          CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}

Commit e pubblica. La prima esecuzione inizia non appena GitHub riceve la pubblicazione.

Vite base path: Le app Vite amate spesso hanno bisogno base: './' in vite.config.ts così che i file caricano all'interno della shell nativa. Se gli utenti vedono uno schermo bianco dopo un aggiornamento OTA, correggi base, pubblica nuovamente e lascia che il workflow ripubblichi.

Bundle crittografati: Se utilizzi Capgo crittografia, aggiungi CAPGO_PRIVATE_KEY come un secondo segreto GitHub e passa --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" nel passaggio di caricamento.

Step 4 — Pubblica conferma attiva un deploy

1. In Lovable, apporta una piccola modifica visibile (ad esempio il testo del pulsante di etichetta)
2. Clicca Pubblica
3. Su GitHub, apri Azioni e guarda Capgo Aggiornamenti Live
4. Quando il lavoro è verde, apri il tuo Capgo console e conferma un nuovo pacchetto nel production canale
5. Una volta confermata la modifica, verificare che arrivi sul dispositivo con l'app installata (potrebbe richiedere un minuto a seconda delle impostazioni del canale)

✅ Successo: Pubblica in Lovable → verde GitHub Azione → nuovo bundle in Capgo → gli utenti ricevono l'aggiornamento.

Risoluzione dei problemi

Per ulteriori modelli di workflow (rami di feature, canali PR, crittografia), vedere GitHub integrazione di Actions.

Cosa raccontare al tuo cliente

Invitali a consultare questo checklist:

1. Tu già collegato Lovable a GitHub e configurato Capgo sull'app mobile.
2. Essi aggiungono un GitHub segreto: CAPGO_TOKEN con la loro Capgo API chiave (pagina apikeys).
3. Essi cliccano Pubblica in Lovable ogni volta che vogliono che gli utenti ricevano le modifiche.
4. Non eseguono mai npx @capgo/cli localmente a meno che non vogliono.

Ciò corrisponde all'esperienza di un solo clic che hanno richiesto: Pubblica in Lovable è il pulsante; GitHub Azioni e Capgo si occupano del resto.

Continua a procedere

• Converti Lovable in iOS e Android — Configurazione completa di Capacitor + Capgo se non hai ancora avvolto l'app
• Costruzione e rilascio automatico con GitHub Actions — Rilasci e incrementi di versione basati su tag
• Integrazione GitHub Actions — Canali multipli e anteprime dei PR
• Capgo Live Updates — Canali, rollback e statistiche di adozione