Paquets

Les paquets de Bundles sont les packages de mise à jour centraux dans Capgo. Chaque paquet de Bundles contient les actifs web (HTML, CSS, JS) qui composent le contenu de votre application. Le module Bundles API vous permet de gérer ces packages de mise à jour, y compris la liste et la suppression des packages.

Comprendre les Bundles

Un bundle représente une version spécifique du contenu web de votre application et comprend :

• Bundle (version): Numéro de version sémantique pour le bundle
• Checksum : Hash unique pour vérifier l'intégrité du bundle
• Informations de stockage : Détails sur la façon et le lieu où le bundle est stocké
• Exigences natives : Exigences minimales de version de l'application native
• Métadonnées: Temps de création, propriété et autres informations de suivi

Création de Bundle Manuelle (Sans CLI)

Voici comment créer et télécharger des bundles manuellement sans utiliser le Capgo CLI :

Étape 1 : Construire votre application

Tout d’abord, construisez les actifs web de votre application :

npm run build

Étape 2 : Créer un Zip de Bundle en Utilisant les Mêmes Packages que Capgo CLI

Important: Utilisez les mêmes packages JavaScript exacts que Capgo CLI utilise internement pour garantir la compatibilité.

Installez les Packages Requis

npm install adm-zip @tomasklaen/checksum

Créer un Bundle Zip avec JavaScript (Même que Capgo CLI)

Remarque : Dans les exemples ci-dessous, version fait référence au nom du bundle (version) utilisé par API.

const fs = require('node:fs');
const path = require('node:path');
const os = require('node:os');
const AdmZip = require('adm-zip');
const { checksum: getChecksum } = require('@tomasklaen/checksum');

// Exact same implementation as Capgo CLI
function zipFileUnix(filePath) {
  const zip = new AdmZip();
  zip.addLocalFolder(filePath);
  return zip.toBuffer();
}

async function zipFileWindows(filePath) {
  console.log('Zipping file windows mode');
  const zip = new AdmZip();

  const addToZip = (folderPath, zipPath) => {
    const items = fs.readdirSync(folderPath);

    for (const item of items) {
      const itemPath = path.join(folderPath, item);
      const stats = fs.statSync(itemPath);

      if (stats.isFile()) {
        const fileContent = fs.readFileSync(itemPath);
        zip.addFile(path.join(zipPath, item).split(path.sep).join('/'), fileContent);
      } else if (stats.isDirectory()) {
        addToZip(itemPath, path.join(zipPath, item));
      }
    }
  };

  addToZip(filePath, '');
  return zip.toBuffer();
}

// Main zipFile function (exact same logic as CLI)
async function zipFile(filePath) {
  if (os.platform() === 'win32') {
    return zipFileWindows(filePath);
  } else {
    return zipFileUnix(filePath);
  }
}

async function createBundle(inputPath, outputPath, version) {
  // Create zip using exact same method as Capgo CLI
  const zipped = await zipFile(inputPath);

  // Write to file
  fs.writeFileSync(outputPath, zipped);

  // Calculate checksum using exact same package as CLI
  const checksum = await getChecksum(zipped, 'sha256');

  return {
    filename: path.basename(outputPath),
    version: version,
    size: zipped.length,
    checksum: checksum
  };
}

// Usage
async function main() {
  try {
    const result = await createBundle('./dist', './my-app-1.2.3.zip', '1.2.3');
    console.log('Bundle info:', JSON.stringify(result, null, 2));
  } catch (error) {
    console.error('Error creating bundle:', error);
  }
}

main();

Étape 3 : Calculer la Somme de Chiffres SHA256 en Utilisant le Même Package que CLI

const fs = require('node:fs');
const { checksum: getChecksum } = require('@tomasklaen/checksum');

async function calculateChecksum(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  // Use exact same package and method as Capgo CLI
  const checksum = await getChecksum(fileBuffer, 'sha256');
  return checksum;
}

// Usage
async function main() {
  const checksum = await calculateChecksum('./my-app-1.2.3.zip');
  console.log('Checksum:', checksum);
}

main();

Étape 4 : Télécharger le Bundle dans votre Stockage

Téléchargez votre fichier zip dans n'importe quel stockage web accessible :

# Example: Upload to your server via scp
scp my-app-1.2.3.zip user@your-server.com:/var/www/bundles/

# Example: Upload to S3 using AWS CLI
aws s3 cp my-app-1.2.3.zip s3://your-bucket/bundles/

# Example: Upload via curl to a custom endpoint
curl -X POST https://your-storage-api.com/upload \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -F "file=@my-app-1.2.3.zip"

Importantcontexte : Page/zone : Page du programme de récompense pour les bugs. Rôle : Étiquette de l'IHM. Vu dans : page bug-bounty.astro. Clé de message `bug_bounty_important_label` (Étiquette importante du programme de récompense pour les bugs). : Votre bundle doit être via HTTPS URL (no authentication required). Capgo’s servers need to download the bundle from this URL.

via une URL HTTPS (aucune authentification requise). Les serveurs de __CAPGO_KEEP_0__ doivent télécharger le bundle à partir de cette URL.

• https://your-storage.com/bundles/my-app-1.2.3.zip
• https://github.com/username/repo/releases/download/v1.2.3/bundle.zip
• https://cdn.jsdelivr.net/gh/username/repo@v1.2.3/dist.zip

Step 5: Register Bundle with Capgo API

Enregistrez le bundle externe avec Capgo à l'aide d'appels directs API :

async function registerWithCapgo(appId, version, bundleUrl, checksum, apiKey) {
  const fetch = require('node-fetch');

  // Create bundle (version)
  const response = await fetch('https://api.capgo.app/bundle/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'authorization': apiKey
    },
    body: JSON.stringify({
      app_id: appId,
      version: version,
      external_url: bundleUrl,
      checksum: checksum
    })
  });

  if (!response.ok) {
    throw new Error(`Failed to create bundle: ${response.statusText}`);
  }

  const data = await response.json();
  console.log('Bundle created:', data);

  return data;
}

API Paramètres

Paramètre	Description	Obligatoire
app_id	Votre identifiant d'application	Oui
version	Bundle (version) version semantique Exemple : "1.2.3"	Oui
external_url	Accessible au public URL HTTPS où le bundle peut être téléchargé (pas d'authentification requise)	Oui
checksum	Checksum SHA256 du fichier zip	Oui

Exigences de structure du bundle

Votre zip de bundle doit respecter ces exigences :

1. Fichier d'index de racine: Doit avoir index.html au niveau de base
2. Capacitor Intégration: Doit appeler notifyAppReady() dans votre application code
3. Chemins d'actifs: Utilisez des chemins relatifs pour tous les actifs

Structure de Bundle valide

bundle.zip
├── index.html
├── assets/
│   ├── app.js
│   └── styles.css
└── images/

Exemple complet du flux de travail manuel

Script Node.js simple pour compresser, calculer la somme de contrôl’et envoyer à Capgo :

const fs = require('node:fs');
const os = require('node:os');
const AdmZip = require('adm-zip');
const { checksum: getChecksum } = require('@tomasklaen/checksum');
const fetch = require('node-fetch');

async function deployToCapgo() {
  const APP_ID = 'com.example.app';
  const VERSION = '1.2.3';
  const BUNDLE_URL = 'https://your-storage.com/bundles/app-1.2.3.zip';
  const API_KEY = process.env.CAPGO_API_KEY;

  // 1. Create zip (same as Capgo CLI)
  const zip = new AdmZip();
  zip.addLocalFolder('./dist');
  const zipped = zip.toBuffer();

  // 2. Calculate checksum (same as Capgo CLI)
  const checksum = await getChecksum(zipped, 'sha256');
  console.log('Checksum:', checksum);

  // 3. Upload to your storage (replace with your upload logic)
  // fs.writeFileSync('./bundle.zip', zipped);
  // ... upload bundle.zip to your storage ...

  // 4. Register with Capgo API
  const response = await fetch('https://api.capgo.app/bundle/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'authorization': API_KEY
    },
    body: JSON.stringify({
      app_id: APP_ID,
      version: VERSION,
      external_url: BUNDLE_URL,
      checksum: checksum
    })
  });

  if (!response.ok) {
    throw new Error(`Failed: ${response.statusText}`);
  }

  console.log('Bundle registered with Capgo!');
}

deployToCapgo().catch(console.error);

Installer les dépendances :

npm install adm-zip @tomasklaen/checksum node-fetch

Vérification de l'intégrité

Calcul de la somme de contrôle JavaScript (Même que Capgo CLI)

Utilisez le même paquet et la même méthode que Capgo CLI utilise internement :

const fs = require('node:fs');
const { checksum: getChecksum } = require('@tomasklaen/checksum');

async function calculateChecksum(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  // Use exact same package and method as Capgo CLI
  const checksum = await getChecksum(fileBuffer, 'sha256');
  return checksum;
}

// Verify checksum matches
async function verifyChecksum(filePath, expectedChecksum) {
  const actualChecksum = await calculateChecksum(filePath);
  const isValid = actualChecksum === expectedChecksum;

  console.log(`File: ${filePath}`);
  console.log(`Expected: ${expectedChecksum}`);
  console.log(`Actual:   ${actualChecksum}`);
  console.log(`Valid:    ${isValid}`);

  return isValid;
}

// Usage
async function main() {
  const bundleChecksum = await calculateChecksum('./my-app-1.2.3.zip');
  console.log('SHA256 Checksum:', bundleChecksum);
}

main();

Importance de la somme de contrôle

• Intégrité du Bundle: Vérifie que le bundle n'a pas été corrompu pendant le transfert
• API Vérification: Capgo vérifie les checksums avant d'accepter les bundles
• Vérification du Plugin: Le plugin mobile vérifie les checksums avant d'appliquer les mises à jour

Meilleures Pratiques

1. Gestion du Bundle (version): Utilisez : la versionnement semantique : de manière cohérente
2. Optimisation de Stockage: Supprimer les bundles inutilisés périodiquement
3. Compatibilité du Bundle (version): Définir les exigences de version native minimale appropriées
4. Stratégie de Sauvegarde: Maintenir des sauvegardes des bundles critiques (versions)

Points de terminaison

GET

https://api.capgo.app/bundle/

Récupérer les informations sur le bundle. Retourne 50 bundles par page.

Paramètres de Requête

• app_id: Obligatoire. L'identifiant de votre application
• page: Facultatif. Numéro de page pour la pagination

Type de réponse

interface Bundle {
  app_id: string
  bucket_id: string | null
  checksum: string | null
  created_at: string | null
  deleted: boolean
  external_url: string | null
  id: number
  minUpdateVersion: string | null
  name: string
  native_packages: Json[] | null
  owner_org: string
  r2_path: string | null
  session_key: string | null
  storage_provider: string
  updated_at: string | null
  user_id: string | null
}

Exemple de requête

# Get all bundles
curl -H "authorization: your-api-key" \
  "https://api.capgo.app/bundle/?app_id=app_123"

# Get next page
curl -H "authorization: your-api-key" \
  "https://api.capgo.app/bundle/?app_id=app_123&page=1"

Exemple de réponse

{
  "data": [
    {
      "id": 1,
      "app_id": "app_123",
      "name": "1.0.0",
      "checksum": "abc123...",
      "minUpdateVersion": "1.0.0",
      "storage_provider": "r2",
      "created_at": "2024-01-01T00:00:00Z",
      "updated_at": "2024-01-01T00:00:00Z",
      "deleted": false,
      "owner_org": "org_123",
      "user_id": "user_123"
    }
  ]
}

SUPPRIMER

https://api.capgo.app/bundle/

Supprimer un ou plusieurs bundles pour une application. Utilisez avec prudence car cette action ne peut pas être annulée.

Paramètres de requête

Pour supprimer un bundle spécifique :

interface BundleDelete {
  app_id: string
  version: string
}

Pour supprimer tous les bundles :

interface BundleDeleteAll {
  app_id: string
}

Exemples de requêtes

# Delete specific bundle
curl -X DELETE \
  -H "authorization: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "app_id": "app_123",
    "version": "1.0.0"
  }' \
  https://api.capgo.app/bundle/

# Delete all bundles
curl -X DELETE \
  -H "authorization: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "app_id": "app_123"
  }' \
  https://api.capgo.app/bundle/

Réponse de succès

{
  "status": "ok"
}

POST

https://api.capgo.app/bundle/

Créer un nouveau bundle avec une URL externe.

Corps de la demande

interface CreateBundleBody {
  app_id: string
  version: string
  external_url: string // Must be publicly accessible HTTPS URL
  checksum: string
}

Exemple de demande

curl -X POST \
  -H "authorization: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "app_id": "com.example.app",
    "version": "1.2.3",
    "external_url": "https://your-storage.com/bundles/app-1.2.3.zip",
    "checksum": "a1b2c3d4e5f6789abcdef123456789abcdef123456789abcdef123456789abcd"
  }' \
  https://api.capgo.app/bundle/

Réponse de succès

{
  "status": "ok"
}

POST (Métadonnées)

https://api.capgo.app/bundle/metadata

Met à jour les métadonnées du bundle, telles que les informations de lien et de commentaire.

Corps de la requête

interface UpdateMetadataBody {
  app_id: string
  version_id: number // bundle (version) id
  link?: string
  comment?: string
}

Exemple de requête

curl -X POST \
  -H "authorization: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "app_id": "app_123",
    "version_id": 456,
    "link": "https://github.com/myorg/myapp/releases/tag/v1.0.0",
    "comment": "Fixed critical bug in authentication"
  }' \
  https://api.capgo.app/bundle/metadata

Réponse de succès

{
  "status": "success"
}

METTRE À JOUR

https://api.capgo.app/bundle/

Associer un bundle à un canal spécifique. Cela relie un bundle (version) à un canal pour la distribution.

Corps de la demande

interface SetChannelBody {
  app_id: string
  version_id: number // bundle (version) id
  channel_id: number
}

Exemple de requête

curl -X PUT \
  -H "authorization: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "app_id": "app_123",
    "version_id": 456,
    "channel_id": 789
  }' \
  https://api.capgo.app/bundle/

Réponse de succès

{
  "status": "success",
  "message": "Bundle 1.0.0 set to channel production"
}

Gestion des erreurs

Scénarios d'erreurs courants et leurs réponses :

// Bundle not found
{
  "error": "Bundle not found",
  "status": "KO"
}

// Invalid bundle (version) format
{
  "error": "Invalid version format",
  "status": "KO"
}

// Storage error
{
  "error": "Failed to delete bundle from storage",
  "status": "KO"
}

// Permission denied
{
  "error": "Insufficient permissions to manage bundles",
  "status": "KO"
}

Utilisations courantes

1. Nettoyage des anciens bundles (Versions)

// Delete outdated beta bundles (versions)
{
  "app_id": "app_123",
  "version": "1.0.0-beta.1"
}

2. Réinitialisation de l'application

// Remove all bundles to start fresh
{
  "app_id": "app_123"
}

Considérations de stockage

1. Politique de conservationDéfinir la durée de conservation des anciens bundles
2. Gestion de la tailleSurveiller les tailles des bundles et l'utilisation de stockage
3. Stratégie de sauvegarde: Pensez à sauvegarder les bundles critiques (versions)
4. Optimisation des coûts: Supprimez les bundles inutiles pour optimiser les coûts de stockage

Continuez depuis les Bundles

Si vous utilisez les Bundles pour planifier la gestion de stockage et de fichiers, connectez-l’avec @capgo/capacitor-data-storage-sqlite for the implementation detail in @capgo/capacitor-data-storage-sqlite, @capgo/capacitor-data-storage-sqlite pour la capacité native dans l'utilisation de @capgo/capacitor-data-storage-sqlite, @capgo/capacitor-fichier pour le détail d'implémentation dans @capgo/capacitor-fichier, En utilisant @capgo/capacitor-fichier pour la capacité native dans l'utilisation de @capgo/capacitor-fichier, et @capgo/capacitor-téléchargeur pour le détail d'implémentation dans @capgo/capacitor-téléchargeur.