Il tuo cliente vuole un singolo tasto in Lovable per inviare modifiche a ogni utente attivo. Hai già verificato che il percorso di aggiornamento funziona manualmente:
npx @capgo/cli@latest bundle upload --channel=production --auto-bumpL'elemento mancante non è un altro comando da terminale dentro Lovable. Lovable non può eseguire Capgo al momento del Publish. Quando la sincronizzazione di GitHub è abilitata, Publish invia un commit al tuo repo. GitHub Actions esegue il build e bundle upload lo fa per te.
Questa guida spiega l'unico setup manuale richiesto al client: aggiungere CAPGO_TOKEN come segreto GitHub. Per il file di workflow, copia e incolla l'istruzione AI in Lovable (Step 3).
Come funziona la pipeline
| Step | Chi | Cosa succede |
|---|---|---|
| 1 | Client | Modifica l'app in Lovable e clicca su Publish |
| 2 | Lovable | Commit e push su GitHub (solitamente main) |
| 3 | Azioni GitHub | npm ci, npm run build, bundle upload --auto-bump su Capgo |
| 4 | Capgo | I dispositivi attivi sul production channel ricevono l'update |
Niente SSH, niente CLI locale, nessun click extra dopo aver configurato il secret.
Prerequisiti
- Progetto Lovable connesso a GitHub (guida all'export)
- Capacitor +
@capgo/capacitor-updaternel repo (Guida da Lovable a mobile) - App registrata in Capgo con
capacitor.config.tsche punta al correttoappId productionchannel esiste ed è collegato ai build eseguiti dagli utenti
Perché --auto-bump
Ogni upload di Capgo richiede una nuova versione del bundle univoca. Lovable Publish non incrementa package.json per te, quindi la CI fallirebbe al secondo deploy se riusi la stessa versione.
--auto-bump legge l'ultima versione sul channel (o app) e la incrementa. Il livello di default è minor. Puoi passare --auto-bump patch o --auto-bump major se preferisci.
Passaggio 1 — Crea una chiave Capgo API
- Apri console.capgo.app/apikeys/
- Crea una chiave API con i permessi per fare l'upload dei bundle della tua app
- Copia la chiave una sola volta. Non potrai più vederne il valore completo
Tratta questa chiave come una password. Non committarla mai su Git e non incollarla nella chat di Lovable.
Passaggio 2 — Aggiungi CAPGO_TOKEN in GitHub (l'unico passaggio relativo alle env)
Questo è il passaggio da inviare a Kuldeep o a qualsiasi client che possiede il repo.
- Apri il repository GitHub che Lovable sincronizza
- Vai su Impostazioni → Secret e variabili → Actions
- Clicca su Nuovo secret del repository
- Nome:
CAPGO_TOKEN - Valore: incolla la chiave Capgo API dal Passaggio 1
- Salva
GitHub inserisce il secret nei workflow come ${{ secrets.CAPGO_TOKEN }}. Il workflow qui sotto lo legge come CAPGO_TOKEN variabile d'ambiente per Capgo CLI.
Se il repo fa parte dell'organizzazione del tuo cliente, dovrà aggiungere il secret nel loro repo. Ti serve solo la chiave in GitHub, non nelle impostazioni di Lovable.
Passaggio 3 — Incolla questo prompt in Lovable
Copia il blocco qui sotto nella chat di Lovable. Se il tuo branch di default non è main, sostituisci main nel workflow con il nome del tuo branch.
Add Capgo Live Updates CI with GitHub Actions.
Create `.github/workflows/capgo-live-updates.yml` (create folders if needed). Start from this YAML, then adapt install/build to this project while keeping Capgo upload + CAPGO_TOKEN secret behavior:
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 --auto-bump
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}
Rules:
- Do not hardcode any Capgo API key in the repo or in chat.
- The workflow must read CAPGO_TOKEN only from GitHub Actions secrets (`${{ secrets.CAPGO_TOKEN }}`).
- Keep `--auto-bump` on the upload command so each Publish gets a new unique bundle version.
- Prefer the project's real production build script from package.json (for example `npm run build` or `vite build`).
- If package-lock.json is missing, use `npm install` instead of `npm ci`.
- Do not modify app UI or Capacitor config for this task.
- Commit the workflow file so the next Publish pushes it to GitHub.Dopo che Lovable ha applicato la modifica, clicca su Publish così il workflow verrà caricato su GitHub.
Alternativa manuale
Se preferisci non usare la chat di Lovable, crea .github/workflows/capgo-live-updates.yml usando solo questo YAML (non il testo del prompt). Adatta i passaggi di install/build come indicato sopra se il tuo progetto è diverso, poi fai commit e push.
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 --auto-bump
env:
CAPGO_TOKEN: ${{ secrets.CAPGO_TOKEN }}Vite base path: Le app Lovable Vite spesso richiedono base: './' in vite.config.ts so assets load inside the native shell. If users see a white screen after an OTA update, ask Lovable to set base: './', pubblica di nuovo e lascia che il workflow faccia il redeploy.
Bundle criptati: Se utilizzi la crittografia Capgo, aggiungi CAPGO_PRIVATE_KEY come secondo segreto GitHub e passa --key-data-v2 "${{ secrets.CAPGO_PRIVATE_KEY }}" nella fase di upload.
Passaggio 4 — Confirm Publish avvia il deploy
- In Lovable, effettua una piccola modifica visibile (ad esempio il testo di un bottone)
- Clicca su Publish
- Su GitHub, apri Actions e controlla Capgo Live Updates
- Quando il job è verde, apri la tua console Capgo e conferma il nuovo bundle su
productionchannel - Su un dispositivo con l'app installata, verifica che la modifica arrivi (potrebbe volerci un minuto a seconda delle impostazioni del channel)
✅ Successo: Pubblica in Lovable → Action GitHub verde → nuovo bundle in Capgo → gli utenti ricevono l'update.
Risoluzione problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il workflow non parte mai | Il push è avvenuto su un branch diverso da main |
Cambia branches nel workflow o pubblica su main |
CAPGO_TOKEN / errore di autenticazione |
Secret mancante o nome errato | Il Secret deve essere esattamente CAPGO_TOKEN sotto Actions secrets |
| Versione già esistente | L'upload ha riutilizzato la stessa versione del bundle | Mantieni --auto-bump nello step di upload (o passa --auto-bump patch) |
Il build fallisce su npm ci |
Lockfile non sincronizzato | Esegui npm install localmente, fai il commit package-lock.json, pubblica di nuovo |
| Upload riuscito, schermata bianca | Errato webDir o Vite base |
Abbina capacitor.config.ts webDir all'output di build (dist per Vite) e imposta base: './' |
| Gli utenti non vedono l'aggiornamento | Channel non collegato alla build | In Capgo, collega la build del dispositivo a production o imposta il channel su public |
Per altri pattern di workflow (feature branch, PR channel, crittografia), vedi Integrazione con GitHub Actions.
Cosa dire al tuo cliente
Inviagli questa checklist:
- Tu hai già collegato Lovable a GitHub e configurato Capgo nell'app mobile.
- Loro aggiungono un secret GitHub:
CAPGO_TOKENcon la loro chiave Capgo API (pagina apikeys). - Loro cliccano Pubblica in Lovable ogni volta che vogliono che gli utenti ricevano le modifiche.
- Non eseguono mai
npx @capgo/cliin locale, a meno che non lo vogliano.
È esattamente l'esperienza a un clic che volevano: Publish in Lovable è il pulsante; GitHub Actions e Capgo fanno il resto.
Continua
- Converti Lovable in iOS e Android — Setup completo di Capacitor + Capgo se non hai ancora wrappato l'app
- Build e release automatiche con GitHub Actions — Release basate su tag e bump di versione
- Integrazione con GitHub Actions — Canali multi-channel e PR preview
- Capgo Live Updates — Canali, rollback e statistiche di adozione
