# Utilisez l'IA pour accéder à Licentivo Launch

> Les modifications non publiées adoptent actuellement l'échange d'identité de compte. Les responsabilités spécifiques et les contraintes de migration sont détaillées dans [Achat Term et Limites SDK de compte ](/fr/launch-documents/account-purchase-boundary/). Launch calcule le terme d'achat ; Licentivo SDK exécute l'autorisation.

Dans le backend Launch, **Opérations → Accès rapide AI** va générer une description de tâche en anglais qui peut être donnée aux outils de programmation AI. Il utilise le magasin actuel, les logiciels existants et les configurations disponibles publiquement des packages publiés, et nécessite que l’AI installe le package client Launch disponible publiquement, appelle des API réelles, place des vérifications de permissions dans les opérations commerciales, puis complète le test d’intégration.

La navigation **Vérification d’intégration & Code / Accès rapide AI** sur la page d’intégration du programme mène aussi à la même fonctionnalité. Le développement manuel ne nécessite pas d’AI ; vous pouvez lire directement le [Guide d’intégration manuelle en neuf langues ](/fr/launch-documents/manual-integration/).

## Préparation avant génération

1. Créez des packages logiciels et de vente dans Launch, et associez les packages aux produits Licentivo et aux politiques d’autorisation.
2. Publiez les packages dans l'environnement `sandbox` ou `live` pour les tester.
3. Assurez-vous que l'adresse publique de Launch est accessible par le logiciel client et utilisez HTTPS dans les environnements formels.
4. Dans **Intégration de programme → Vérification de l'intégration & Code**, lisez les informations sur le produit et confirmez que le mapping du produit et la clé publique de signature passent la vérification.
5. Identifiez clairement les actions commerciales réelles à protéger, telles que `export`, `save` ou `render` ; ne vous contentez pas d’écrire « le logiciel entier ».

Les brouillons peuvent être générés sans compléter la configuration du produit, mais les brouillons marqueront clairement les éléments à remplir et ne peuvent pas être utilisés comme configurations d'intégration livrables. Après avoir complété les configurations du produit et de l'environnement, vous devrez régénérer.

## Générer des invites dans le backend

1. Choisissez Go, Python, C#, Java, JavaScript / Node.js, Rust, Ruby, C, ou C++. Pour les solutions backend web, l'utilisation de Go ne compte pas comme un langage SDK supplémentaire.
2. Choisissez Windows, Linux, macOS, ou la plateforme applicable, ainsi qu’un projet de bureau, de backend web ou de service en arrière-plan.
3. Remplissez la structure du projet existante, la méthode de démarrage, le framework UI et les fonctions métiers à protéger en anglais. Ne renseignez pas les mots de passe, clés, données clients ou code source privé.
4. Choisissez le logiciel existant et l’environnement `sandbox` / `live`. Launch lit automatiquement l’adresse du magasin actuel, et Launch mappe les produits, environnements et clés publiques de signature avec Licentivo.
5. Vérifie les versions des paquets, les commandes d'installation, les liens de documentation et les fonctions de connexion complétées dans l'aperçu, puis copie ou télécharge le prompt.
6. Donne le prompt à ton outil de programmation IA pour faire des modifications, compiler et tester localement dans ton projet.

Launch ne génère du texte que dans le navigateur. Il ne se connectera pas automatiquement à un service IA, ne téléchargera pas de projets et n'exécutera pas les programmes générés pour le développeur.

## Le prompt dira à l'IA où télécharger le SDK.

Toutes les vérifications d'installation publique en neuf langues pour la version 0.1.6 ont été réussies (9/9). Les commandes de registre suivantes et les téléchargements natifs ont été vérifiés. Les fichiers Maven Central et les quatre signatures de Java, la version exacte de crates.io de Rust, ainsi que tout le code d'initialisation généré par le backend ont également passé les vérifications indépendantes des utilisateurs ; [v0.1.6 GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6) fournit à la fois des packages natifs et des fichiers hors ligne.

L'invite générée doit inclure une méthode d'installation publique de version fixe correspondant à la langue sélectionnée.

```text
Go:         go get github.com/spf86/licentivo-launch-sdk/pkg/launchclient@v0.1.6
Python:     python -m pip install licentivo-launch==0.1.6
C# / .NET: dotnet add package Licentivo.Launch --version 0.1.6
Java:       com.licentivo.launch:launch-client:0.1.6
Node.js:    npm install @licentivo/launch@0.1.6
Rust:       cargo add licentivo-launch@=0.1.6
Ruby:       gem install licentivo-launch --version 0.1.6
C / C++:    https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6
```

Le code source public, les README pour chaque langue et le statut actuel de la version se trouvent à :

- [Licentivo Launch SDK Repository](https://github.com/spf86/licentivo-launch-sdk)
- [v0.1.6 GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6)
- [Vérification d'installation publique en neuf langues](https://github.com/spf86/licentivo-launch-sdk/blob/main/docs/registry-verification.json)
- [Description de la version et du package](/fr/launch-documents/integration-packages/)
- [Guide d’intégration manuelle dans neuf langages](/fr/launch-documents/manual-integration/)
- [Architecture d'accès à l'application et exigences de sécurité ](/fr/launch-documents/software-sdk-integration/)
- [Liste de contrôle d'acceptation de l'accès ](/fr/launch-documents/acceptance/)

Installez uniquement le package Launch pour la langue sélectionnée. v0.1.6 inclut déjà le SDK officiel Licentivo v0.11.6, l'adaptateur par défaut et la configuration des liens, donc il n'est pas nécessaire d'installer un SDK officiel séparé.

## Les invites indiqueront à l'IA comment accéder

Les invites configurées incluent des fonctions de connexion générées par le backend. Cette fonction contient déjà l'adresse publique du magasin, le mappage des produits de Launch à Licentivo, la clé publique de signature et l'environnement de paiement. L'IA n'a pas besoin de deviner ou de saisir manuellement les deux numéros de produit internes, ni de créer `launch-config.json` ou `product.json`.

Le `config.yaml` privé côté serveur est uniquement utilisé pour exécuter le site web Launch et ne doit jamais être inclus dans les applications clients, les invites ou les packages d'installation.

L'IA doit modifier le logiciel client selon le cycle de vie suivant :

```text
Connect/connect → Login or Restore → RunFeature → Logout / Close
                                      └──────────→ ReleaseDevice (explicit device unlink only)
```

- `Connect/connect` crée le client Launch et initialise le SDK officiel intégré ; cela ne signifie pas que le compte est déjà connecté ou que les fonctionnalités sont déjà autorisées.
- `Login` obtient les identifiants du produit pour ce compte en utilisant l'e-mail et le mot de passe avec lesquels le client s'est inscrit dans le magasin actuel.
- `Restore` restaure les sessions mémorisées depuis le stockage sécurisé ; s'il n'y a pas de session, il affiche la connexion, et le refus n'est pas considéré comme un succès hors ligne.
- `RunFeature` doit envelopper les actions réelles comme exporter, sauvegarder, rendre ou exécuter des tâches en arrière-plan. Désactiver les boutons ne peut pas remplacer les vérifications aux points d'exécution.
- `Logout` appelle d'abord le SDK officiel pour une déconnexion unifiée, puis efface la session du compte ; `ReleaseDevice` est une entrée compatible pour le même processus de déconnexion. `Close` conserve la liaison de l'appareil lors d'une fermeture normale.
- L'objet client doit rester actif pendant que l'application tourne afin que le SDK puisse effectuer des signaux de vie, des sièges flottants et des règles en temps réel.

Les applications web ne font des vérifications d'autorisation que sur des backends de confiance. Node.js / Electron place les identifiants et les SDK dans le processus principal ou côté serveur, et le navigateur et le renderer ne stockent pas les secrets d'autorisation.

## Ce que l'IA doit livrer

Le prompt demande à l'IA de compléter et de rapporter ce qui suit :

1. Vérifier la version de la langue, la gestion des dépendances, les processus de démarrage et d'arrêt des projets existants, et les opérations commerciales réelles qui nécessitent une protection.
2. Utilisez la commande de version fixe ci-dessus pour installer un paquet Launch et vérifiez les vraies interfaces dans le README correspondant à la langue.
3. Ajoutez la connexion au compte client, les messages d'erreur et la récupération sécurisée de session ; ne stockez pas les mots de passe ou licences complètes dans le code source ou les logs.
4. Initialisez en utilisant les fonctions de connexion fournies par le back-end ; ne créez pas de numéros de produit, de clés publiques de signature ou de fichiers de configuration vous-même.
5. Utilisez `RunFeature` ou les méthodes correspondantes dans chaque point d’opération commerciale protégé, en gérant correctement le comptage et les tentatives.
6. Faites la distinction entre échec de compte, email en attente de vérification, synchronisation des droits, non-achat, expiré, suspendu, appareil plein, échec réseau et expiration hors ligne.
7. Mettre en œuvre la fermeture normale, la déconnexion du compte et la libération explicite des appareils, et séparer les caches par magasin, compte, produit et environnement.
8. Exécuter la compilation et les tests appropriés au projet, et enfin lister les fichiers modifiés, la cartographie des fonctionnalités, les résultats réels et les étapes d'acceptation par le client.

Après que l'IA ait généré le code, les développeurs doivent toujours vérifier que les noms des fonctions sont entièrement conformes aux politiques Licentivo et effectuer des tests de bout en bout sur un compte magasin sandbox réel.

## Contenu exclu de la consigne

Les invites ne doivent inclure que des sources de magasin disponibles publiquement, la cartographie des produits, l'environnement, la version du package et les clés publiques de signature. Les éléments suivants ne doivent pas être inclus dans l'invite :

- Emails des clients, mots de passe, sessions de connexion et jetons de rafraîchissement ;
- Licences complètes, identifiants d'appareils et caches d'autorisation locaux ;
- Clés d’API de gestion Licentivo ;
- Clés Stripe, PayPal, Waffo ou Paddle ;
- Connexions à la base de données, `master_key`, et `config.yaml` côté serveur ;
- Pas besoin de fournir le code source privé, les données commerciales ou les journaux à des outils externes.

Les vérifications de configuration publiques, les brouillons IA et les builds locaux de Launch ne peuvent pas prouver que les paiements réels, l’émission de licences ou les activations externes ont réussi. Les environnements sandbox de paiement, les comptes de boutique et l’environnement Licentivo nécessitent une validation séparée.

## Liste de vérification d’acceptation après intégration

- Les nouveaux clients peuvent se connecter et les emails non vérifiés ou les mauvais mots de passe génèrent des messages d’erreur clairs mais pas trop révélateurs.
- Les comptes achetés peuvent utiliser les fonctionnalités cibles ; les comptes non achetés, expirés ou suspendus ne peuvent pas exécuter le même code business.
- Après un redémarrage, l'utilisateur ne peut continuer que si la session est restaurée avec succès et que les vérifications d'autorisation sont concluantes.
- Les stratégies hors ligne efficaces fonctionnent, les licences hors ligne sont rejetées lorsqu'elles expirent ; les erreurs claires 401/403/404 ne sont pas considérées comme des succès hors ligne.
- Les comptages d'utilisation des fonctionnalités ne sont soumis correctement qu'en cas de succès commercial ; les échecs et les tentatives de réessai ne sont pas déduits plusieurs fois.
- Les fermetures régulières conservent les liaisons de l'appareil ; la déconnexion explicite appelle d'abord la déconnexion officielle du SDK, conserve les journaux pour révocation et rapporte les résultats réels.
- Les battements de cœur du siège flottant fonctionnent pendant que l'application est active, et le temps de récupération après une sortie anormale respecte la politique d'autorisation en vigueur.
- Changer de magasin, de compte, de produit ou d'environnement ne réutilise pas le cache d'une autre identité.

Une frontière d’acceptation automatique et externe plus complète peut être trouvée dans [acceptance.md](/fr/launch-documents/acceptance/).

## Utilisation d’un générateur de prompt dans les packages de distribution du code source

`licentivo-launch-0.1.6-source.zip` conserve les fichiers suivants pour aider à générer des prompts avec la même structure dans vos propres outils :

- `internal/httpapi/web/integration-prompts.js` : module de génération de prompts qui ne dépend ni de pages ni de serveurs ;
- `scripts/integration-prompts.test.mjs` : test local Node ;
- `internal/httpapi/web/integration-state.js` et `scripts/integration-state.test.mjs` : isoler les brouillons de configuration et nettoyer les anciens résultats de validation ;
- Ce guide, les packages d’intégration linguistique, les exemples et les notes d’acceptation.

Le module exporte `integrationTargets` et `buildIntegrationPrompt(options)`. Les options incluent `language`, `appKind`, `platform`, `projectNotes`, `feature`, `merchantOrigin`, `environment`, et le `report` vérifié, retournant `{ text, ready, title, code }`. Si `report` n’est pas fourni, seul un brouillon est généré ; vous ne pouvez pas contourner les vérifications de configuration publique en modifiant manuellement le rapport.

Dans les outils de développement qui supportent les modules ES, vous pouvez générer un brouillon local depuis le répertoire racine du paquet source :

```powershell
@'
import { readFile, writeFile } from 'node:fs/promises';
const source = await readFile('internal/httpapi/web/integration-prompts.js', 'utf8');
const { buildIntegrationPrompt } = await import(
  'data:text/javascript;base64,' + Buffer.from(source).toString('base64')
);
const prompt = buildIntegrationPrompt({
  language: 'python',
  appKind: 'desktop',
  platform: 'windows',
  projectNotes: 'Existing Python desktop application. Add account sign-in and protect report exports.',
  feature: 'export'
});
await writeFile('integration-prompt.md', prompt.text, 'utf8');
console.log(prompt.title);
'@ | node --input-type=module
```

Cette commande ne génère qu’un brouillon non configuré et n’appelle pas l’IA ni les services autorisés. L’accès authentique doit revenir à votre propre instance Launch et sélectionner le logiciel et l’environnement existants pour régénérer une version avec la configuration publique.

Vérifiez le générateur local :

```powershell
node --test scripts/integration-prompts.test.mjs scripts/integration-state.test.mjs
```