Il tuo cliente vuole un unico pulsante in Lovable per pubblicare le modifiche a tutti gli utenti attivi. Hai già dimostrato che il percorso di aggiornamento funziona manualmente:
npx @capgo/cli@latest bundle upload --channel=production --auto-bump
Il pezzo mancante non è un altro comando terminale dentro Lovable. Lovable non può eseguire Capgo alla Pubblicazione. Quando la sincronizzazione GitHub è abilitata, Publish spinge un commit nel tuo repo. GitHub Actions esegue la build e bundle upload per te.
Questa guida copre l'unica configurazione manuale che il tuo cliente deve fare una volta: aggiungere CAPGO_TOKEN come segreto GitHub. Per il file di workflow, copia-incolla l'istruzione AI pronta in Lovable (Passo 3).
Come funziona la pipeline
| Passaggio | Chi | Cosa succede |
|---|---|---|
| 1 | Client | Modifica l'app in Lovable e clicca su Pubblica |
| 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 | 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 al mobile) - App registrata in Capgo con
capacitor.config.tsche punta al correttoappId productionil canale esiste ed è collegato ai build eseguiti dagli utenti
Perché --auto-bump
Ogni upload di Capgo richiede un nuovo bundle version univoco. Lovable Publish non incrementa package.json per te, in modo che la CI fallisca al secondo deploy se riutilizzi la stessa versione.
--auto-bump legge l'ultima versione sul canale (o app) e la incrementa. Il livello predefinito è minor. Puoi passare --auto-bump patch oppure --auto-bump major se preferisci.
Passo 1 — Crea una chiave Capgo API
- Apri console.capgo.app/apikeys/
- Crea una chiave API con i permessi per 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.
Passo 2 — Aggiungi CAPGO_TOKEN in GitHub (l'unico passaggio per le env)
Questo è il passaggio da inviare a Kuldeep e a qualsiasi cliente che possiede il repo.
- Apri il repository GitHub che Lovable sincronizza
- Vai su Impostazioni → Secret e variabili → Azioni
- 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 è nell'organizzazione del tuo cliente, devono aggiungere il secret nel loro repo. Ti serve solo la chiave in GitHub, non nelle impostazioni di Lovable.
Passo 3 — Incolla questo prompt in Lovable
Copia il blocco qui sotto nella chat di Lovable. Se il tuo branch di default non è main, 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 Pubblica così il workflow punta a GitHub.
Alternativa manuale
Se preferisci non usare la chat di Lovable, crea .github/workflows/capgo-live-updates.yml con solo questo YAML (non il testo del prompt). Adatta i passaggi di installazione/build allo stesso modo delle regole sopra se il tuo progetto è diverso, poi 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 necessitano di base: './' nella 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 ripubblichi.
Bundle cifrati: Se usi 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 pulsante)
- Clicca su Pubblica
- Su GitHub, apri Azioni e osserva Live Updates di Capgo
- Quando il job è verde, apri la tua console di Capgo e conferma un nuovo bundle su
productioncanale - Su un dispositivo con l'app installata, verifica che la modifica arrivi (potrebbe volerci un minuto a seconda delle impostazioni del canale)
✅ 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 è andato su un branch diverso da main |
Cambia branches nel workflow o pubblica su main |
CAPGO_TOKEN / errore di autenticazione |
Secret mancante o nome errato | La secret deve essere esattamente CAPGO_TOKEN sotto Actions secrets |
| La versione esiste già | L'upload ha riutilizzato la stessa versione del bundle | Mantieni --auto-bump nel passaggio di upload (oppure passa --auto-bump patch) |
La build fallisce su npm ci |
Lockfile non sincronizzato | Esegui npm install localmente, 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
- Live Updates di Capgo — Canali, rollback e statistiche di adozione