# Licentivo Launch mit KI integrieren

> Die aktuellen unveröffentlichten Änderungen verwenden Kontoidentitätsaustausch; Zuständigkeiten und Migrationseinschränkungen siehe [Kaufzeitraum und Konto-SDK-Grenze](/de/launch-documents/account-purchase-boundary/). Launch berechnet den Kaufzeitraum; das Licentivo SDK führt die Autorisierung aus.

**Betriebswerkzeuge → KI-Schnellintegration** in der Launch-Administration erzeugt eine englische Aufgabenbeschreibung für ein KI-Programmierwerkzeug. Sie verwendet die tatsächliche öffentliche Konfiguration des aktuellen Shops, bestehender Software und veröffentlichter Pläne und fordert die KI auf, das öffentliche Launch-Clientpaket zu installieren, echte APIs aufzurufen, Berechtigungsprüfungen in Geschäftsoperationen einzubauen und Integrationstests abzuschließen.

Auch die Navigation **Integrationsprüfung und Code / KI-Schnellintegration** auf der Programmintegrationsseite führt zu derselben Funktion. Manuelle Entwicklung benötigt keine KI; lesen Sie direkt die [manuelle Integrationsanleitung für neun Sprachen](/de/launch-documents/manual-integration/).

## Vorbereitung vor der Erzeugung

1. Software und Verkaufsplan in Launch erstellen und den Plan mit Licentivo-Produkt und Lizenzrichtlinie verknüpfen.
2. Den Plan in der zu testenden Umgebung `sandbox` oder `live` veröffentlichen.
3. Sicherstellen, dass Kundensoftware die öffentliche Launch-Adresse erreichen kann; Produktion verwendet HTTPS.
4. Unter **Anwendungsintegration → Integrationsprüfung und Code** Produktinformationen lesen und erfolgreiche Prüfung von Produktzuordnung und öffentlichen Signaturschlüsseln bestätigen.
5. Die tatsächlich zu schützenden Geschäftsaktionen wie `export`, `save` oder `render` festlegen, nicht nur „gesamte Software“ schreiben.

Ohne abgeschlossene Produktkonfiguration kann ein Entwurf erzeugt werden, der auszufüllende Punkte ausdrücklich markiert und nicht als auslieferbare Integrationskonfiguration dienen darf. Nach Abschluss der Produkt- und Umgebungskonfiguration erneut erzeugen.

## Prompt in der Administration erzeugen

1. Go, Python, C#, Java, JavaScript / Node.js, Rust, Ruby, C oder C++ wählen. Die Web-Backend-Lösung verwendet Go und zählt nicht als zusätzliche SDK-Sprache.
2. Windows, Linux, macOS oder eine passende Plattform sowie Desktop-, Web-Backend- oder Hintergrunddienstprojekt wählen.
3. Bestehende Projektstruktur, Startverfahren, UI-Framework und zu schützende Geschäftsfunktion auf Englisch angeben. Keine Passwörter, Schlüssel, Kundendaten oder privaten Quellcode eingeben.
4. Bestehende Software und `sandbox` / `live`-Umgebung wählen. Launch liest automatisch aktuelle Shopadresse, Produktzuordnung zwischen Launch und Licentivo, Umgebung und öffentliche Signaturschlüssel.
5. Paketversion, Installationsbefehle, Dokumentationslinks und ausgefüllte Verbindungsfunktion in der Vorschau prüfen, dann den Prompt kopieren oder herunterladen.
6. Den Prompt dem eigenen KI-Programmierwerkzeug geben, damit es Änderungen, Kompilierung und lokale Tests im Projekt durchführt.

Launch erzeugt Text nur im Browser. Es verbindet sich nicht automatisch mit einem KI-Dienst, lädt kein Projekt hoch und führt erzeugte Programme nicht anstelle des Entwicklers aus.

## Der Prompt zeigt der KI, wo das SDK heruntergeladen wird

Die öffentlichen Installationsprüfungen von 0.1.6 für neun Sprachen sind vollständig bestanden (9/9); die folgenden Registry-Befehle und nativen Downloads wurden geprüft. Java-Maven-Central-Dateien und vier Signaturen, die genaue Rust-crates.io-Version und alle von der Administration erzeugten Initialisierungscodes wurden ebenfalls in unabhängigen Verbraucherprojekten geprüft; [v0.1.6 GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6) bietet zudem native Pakete und Offline-Dateien.

Der erzeugte Prompt muss die öffentliche Installationsmethode mit fester Version für die gewählte Sprache enthalten:

```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
```

Öffentlicher Quellcode, README-Dateien aller Sprachen und aktueller Veröffentlichungsstatus befinden sich unter:

- [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)
- [Öffentliche Installationsverifikation für neun Sprachen](https://github.com/spf86/licentivo-launch-sdk/blob/main/docs/registry-verification.json)
- [Versions- und Paketinformationen](/de/launch-documents/integration-packages/)
- [Manuelle Integrationsanleitung für neun Sprachen](/de/launch-documents/manual-integration/)
- [Anwendungsintegrationsarchitektur und Sicherheitsanforderungen](/de/launch-documents/software-sdk-integration/)
- [Integrationsabnahme-Checkliste](/de/launch-documents/acceptance/)

Nur das Launch-Paket der gewählten Sprache installieren. v0.1.6 enthält bereits das offizielle Licentivo SDK v0.11.6, den Standardadapter und die Linkkonfiguration; ein zweites offizielles SDK wird nicht separat installiert.

## Der Prompt erläutert der KI die Integration

Der konfigurierte Prompt enthält die von der Administration erzeugte Verbindungsfunktion. Sie enthält bereits öffentliche Shopadresse, Produktzuordnung von Launch und Licentivo, öffentliche Signaturschlüssel und Zahlungsumgebung. Die KI muss weder zwei interne Produktnummern erraten oder manuell eingeben noch `launch-config.json` oder `product.json` erstellen.

Die private serverseitige `config.yaml` dient nur zum Betrieb der Launch-Website und darf niemals in Kundenanwendung, Prompt oder Installationspaket gelangen.

Die KI muss die Kundensoftware gemäß folgendem Lebenszyklus ändern:

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

- `Connect/connect` erstellt den Launch-Client und initialisiert das eingebettete offizielle SDK; dies bedeutet für sich genommen weder Kontoanmeldung noch Funktionsautorisierung.
- `Login` verwendet E-Mail und Passwort des Kundenkontos im aktuellen Shop, um Produktzugangsdaten dieses Kontos zu erhalten.
- `Restore` stellt eine gemerkte Sitzung aus sicherem Speicher wieder her; ohne Sitzung Anmeldung anzeigen, ausdrückliche Ablehnung darf nicht als Offline-Erfolg gelten.
- `RunFeature` muss tatsächliche Geschäftsaktionen wie Exportieren, Speichern, Rendern oder Hintergrundaufgaben umschließen. Nur eine Schaltfläche zu deaktivieren ersetzt keine Prüfung am Ausführungsort.
- `Logout` ruft zuerst den einheitlichen Logout des offiziellen SDK auf und bereinigt dann die Kontositzung; `ReleaseDevice` ist ein Kompatibilitätseinstieg desselben ausdrücklichen Logout-Ablaufs. `Close` als normales Schließen behält die Gerätebindung.
- Das Clientobjekt sollte während der Anwendungslaufzeit aktiv bleiben, damit das SDK Heartbeats, Floating-Plätze und Laufzeitregeln ausführen kann.

Webanwendungen führen Autorisierungsprüfungen nur im vertrauenswürdigen Backend aus. Node.js / Electron halten Zugangsdaten und SDK im Hauptprozess oder auf dem Server; Browser und Renderer speichern keine Autorisierungsgeheimnisse.

## Was die KI liefern soll

Der Prompt verlangt, dass die KI Folgendes erledigt und berichtet:

1. Sprachversion, Abhängigkeitsverwaltung, Start- und Beendigungsabläufe des bestehenden Projekts sowie tatsächlich zu schützende Geschäftsoperationen prüfen.
2. Mit dem obigen Befehl fester Version ein Launch-Paket installieren und die tatsächlichen Schnittstellen in der README der jeweiligen Sprache prüfen.
3. Kundenkonto-Anmeldung, Fehlerhinweise und sichere Sitzungswiederherstellung ergänzen; Passwörter und vollständige Lizenzen nicht in Quellcode oder Protokollen speichern.
4. Mit der von der Administration bereitgestellten Verbindungsfunktion initialisieren, ohne Produktnummern, öffentliche Signaturschlüssel oder Konfigurationsdateien selbst zu erfinden.
5. Am Ausführungsort jeder geschützten Geschäftsaktion `RunFeature` oder die entsprechende Sprachmethode verwenden und Zählung und Wiederholungen korrekt behandeln.
6. Kontofehler, ausstehende E-Mail-Verifikation, laufende Berechtigungssynchronisierung, keinen Kauf, Ablauf, Aussetzung, volles Gerätelimit, Netzwerkfehler und Offline-Ablauf unterscheiden.
7. Normales Schließen, Konto-Logout und ausdrückliche Gerätefreigabe implementieren und Caches nach Shop, Konto, Produkt und Umgebung isolieren.
8. Geeignete Projektkompilierung und Tests ausführen und abschließend geänderte Dateien, Funktionszuordnung, tatsächliche Ergebnisse und Kundenabnahmeschritte auflisten.

Nach der Codeausgabe durch die KI muss der Entwickler weiterhin prüfen, dass Funktionsnamen exakt zur Licentivo-Richtlinie passen, und einen End-to-End-Test mit einem echten sandbox-Shopkonto durchführen.

## Inhalte, die nicht in den Prompt gehören

Der Prompt enthält nur öffentlich zugänglichen Shop-Origin, Produktzuordnung, Umgebung, Paketversion und öffentliche Signaturschlüssel. Folgende Inhalte dürfen nicht in den Prompt gelangen:

- Kunden-E-Mail, Passwort, Anmeldesitzung und Refresh-Token;
- Vollständige Lizenz, Gerätezugangsdaten und lokaler Lizenzcache;
- Licentivo-Management-API Key;
- Stripe-, PayPal-, Waffo- oder Paddle-Schlüssel;
- Datenbankverbindungen, `master_key` und serverseitige `config.yaml`;
- Privater Quellcode, Geschäftsdaten oder Protokolle, die nicht an externe Tools gegeben werden müssen.

Öffentliche Launch-Konfigurationsprüfung, KI-Entwurf und lokale Kompilierung beweisen keine erfolgreiche echte Zahlung, Lizenzerstellung oder externe Aktivierung. Zahlungs-Sandbox, Shopkonto und Licentivo-Umgebung müssen separat abgenommen werden.

## Abnahme-Checkliste nach der Integration

- Neue Kunden können sich anmelden; nicht verifizierte E-Mail und falsches Passwort erhalten klare Hinweise ohne übermäßige Informationspreisgabe.
- Ein kaufberechtigtes Konto kann die Zielfunktion ausführen; nicht gekaufte, abgelaufene oder ausgesetzte Konten können denselben Geschäftscode nicht ausführen.
- Nach Neustart darf die Nutzung nur nach erfolgreicher Sitzungswiederherstellung und Autorisierungsprüfung fortgesetzt werden.
- Eine gültige Offline-Richtlinie funktioniert, nach Ablauf der Offline-Berechtigung wird abgelehnt; ausdrückliche 401/403/404 werden nicht zu Offline-Erfolg herabgestuft.
- Funktionsnutzungen werden nur bei erfolgreichem Geschäftsvorgang korrekt bestätigt; Fehler und Wiederholungen führen nicht zu doppelter Abbuchung.
- Normales Schließen behält die Gerätebindung; ausdrücklicher Logout ruft zuerst den einheitlichen Logout des offiziellen SDK auf, bewahrt das Journal ausstehender Widerrufe und meldet das tatsächliche Ergebnis.
- Der Floating-Platz-Heartbeat läuft während der Anwendung weiter; die Rückgewinnungszeit nach abnormalem Beenden entspricht der aktuellen Lizenzrichtlinie.
- Ein Wechsel von Shop, Konto, Produkt oder Umgebung verwendet keinen Cache einer anderen Identität erneut.

Vollständigere automatische und externe Abnahmegrenzen siehe [acceptance.md](/de/launch-documents/acceptance/).

## Promptgenerator im Quelldistributionspaket verwenden

`licentivo-launch-0.1.6-source.zip` enthält folgende Dateien, um Prompts gleicher Struktur in eigenen Tools erzeugen zu können:

- `internal/httpapi/web/integration-prompts.js`: Promptgeneratormodul ohne Abhängigkeit von Seite oder Server;
- `scripts/integration-prompts.test.mjs`: lokaler Node-Test;
- `internal/httpapi/web/integration-state.js` und `scripts/integration-state.test.mjs`: Isolierung von Konfigurationsentwürfen und Bereinigung alter Verifikationsergebnisse;
- Diese Anleitung, Integrationspakete aller Sprachen, Beispiele und Abnahmehinweise.

Das Modul exportiert `integrationTargets` und `buildIntegrationPrompt(options)`. Optionen umfassen `language`, `appKind`, `platform`, `projectNotes`, `feature`, `merchantOrigin`, `environment` und den validierten `report`; zurückgegeben wird `{ text, ready, title, code }`. Ohne `report` wird nur ein Entwurf erzeugt; die Prüfung öffentlicher Konfiguration kann nicht durch manuelles Manipulieren des Berichts umgangen werden.

In Entwicklungstools mit ES-Modul-Unterstützung kann im Stammverzeichnis des Quellpakets ein lokaler Entwurf erzeugt werden:

```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
```

Dieser Befehl erzeugt nur einen unkonfigurierten Entwurf und ruft weder KI noch Lizenzdienst auf. Für echte Integration zur eigenen Launch-Instanz zurückkehren, bestehende Software und Umgebung wählen und die Version mit öffentlicher Konfiguration erneut erzeugen.

Lokalen Generator prüfen:

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