smartEngin Licence & buy

Für WordPress-Entwickler: verkaufe & lizenziere dein eigenes Plugin

smartEngin Licence & buy kann auch deine Software lizenzieren. Baue eine winzige, build-freie PHP-Bibliothek in dein WordPress-Plugin ein — sie aktiviert eine Website, hält den Lizenzstatus und liefert automatische Updates, über eine einfache REST-API. Ein Lizenzschlüssel ist nur ein Token, das dieser Server ausgibt; es gibt nichts zu „entschlüsseln“.

Überblick · Schnellstart · Gib es deiner KI · API-Referenz

Schnellstart (≈15 Zeilen)

1. Lege dein Produkt auf deinem Server an (Licence & buy → Products): setze einen slug und eine latest version.
2. Bündle die Bibliothek in deinem Plugin unter lib/smartengin-licence-client/.
3. Erzeuge eine Self_Client-Instanz in deiner Haupt-Plugin-Datei (server_url = deine eigene Seite, auf der Licence & buy läuft):

require_once __DIR__ . '/lib/smartengin-licence-client/self-client.php';

$GLOBALS['my_licence'] = new Self_Client( array(
    'server_url'  => 'https://deine-seite.de', // dein eigener Lizenzserver — an EINER Konstante halten
    'slug'        => 'mein-plugin-slug',        // = Produkt-Slug auf DEINEM Server
    'plugin_file' => __FILE__,
    'version'     => '1.0.0',
) );

// Lizenz-Panel irgendwo im Admin anzeigen:
$GLOBALS['my_licence']->render_panel();

// Premium-Funktionen FAIL-OPEN freischalten (active/expired = lizenziert):
$s = $GLOBALS['my_licence']->get_state();
$licensed = in_array( $s['status'], array( 'active', 'expired' ), true );

Updates laufen danach automatisch über die normalen WordPress-Update-Bildschirme. Halte dich an das Prinzip B + C: ohne gültigen Schlüssel keine Updates; Premium-Funktionen aus, aber der freie Kern und die Nutzerdaten bleiben erhalten; niemals ein „tot ohne Schlüssel“-Modus. Halte den Client fail-open — ist dieser Server nicht erreichbar, läuft das Plugin auf dem letzten bekannten Stand weiter.

Gib das deiner KI

Kopiere den Block unten in ChatGPT oder Claude (zusammen mit deinem Plugin) — die KI kann dann die ganze Integration für dich übernehmen.

Kontext für die KI: Ich möchte mein eigenes WordPress-Plugin mit smartEngin Licence & buy lizenzieren und verkaufen. Es funktioniert über eine kleine, build-freie PHP-Bibliothek (Self_Client), die mit einem Lizenzserver über die REST-API sels/v1 spricht. Ein Lizenzschlüssel ist ein zufälliges, serverseitig gespeichertes Token — clientseitig nichts zu entschlüsseln. Die Durchsetzung liegt nur auf dem Server; der Client muss fail-open sein und dem Prinzip B + C folgen (ohne gültigen Schlüssel keine Updates; Premium aus, freier Kern und Daten bleiben; niemals „tot ohne Schlüssel“).

Tu Folgendes: (1) bündle die Bibliothek unter lib/smartengin-licence-client/; (2) erzeuge EINE Self_Client-Instanz mit server_url, slug, plugin_file, version, und halte die Server-URL an einer einzigen Konstante; (3) zeige render_panel() in meinem Admin; (4) schalte Premium-Funktionen mit einer is_licensed()-Hilfsfunktion frei, die get_state() liest und active/expired als lizenziert behandelt. Baue keinerlei Code-Verschleierung oder Kopierschutz-Tricks ein.

Referenz (öffentlich, roh):
Repository: https://github.com/smartEngin-de/smartengin-licence-client
Integrationsleitfaden: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/integration-guide.md
REST-Referenz: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/rest-reference.md
OpenAPI: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/openapi.yaml
Beispiel-Plugin: https://github.com/smartEngin-de/smartengin-licence-client/tree/main/example/smartengin-licence-example

Was Lizenzierung leistet — ehrlich

Die Lizenzierung von selbstgehostetem PHP ist eine Geschäftsmechanik, kein Kopierschutz: der Code läuft auf dem Server des Kunden, und WordPress-Plugins sind GPL. Die echte Durchsetzung liegt serverseitig — der Update-Kanal, signierte Downloads und Aktivierungslimits. Genau das liefert dieser Server. Halte den Client fail-open, liefere ein gutes Produkt — den kaufmännischen Unterbau erledigt das Lizenzsystem.

Für Entwickler: Windows- & Desktop-Software verkaufen & aktualisieren

Kein WordPress? Derselbe Server lizenziert und aktualisiert auch Software außerhalb von WordPress — vor allem Windows-Desktop-Apps. Der Kunde bekommt neue Versionen still im Hintergrund, so wie sich WordPress-Plugins selbst aktualisieren. Ein fertiger .NET/C#-Referenzclient übernimmt Aktivierung, ausfallsichere Prüfung und das stille Selbst-Update; über dieselbe REST-API funktioniert jede Sprache.

Dieser Abschnitt ist für Software außerhalb von WordPress. Für WordPress-Plugins siehe den Abschnitt darüber — der nutzt die build-freie PHP-Bibliothek.

Schnellstart (.NET / C#)

1. Produkt anlegen (Licence & buy → Products): Plattform auf Windows-App (.exe / .msi), einen Slug und eine Latest Version setzen, deine .exe/.msi als Paket hochladen.
2. Den .NET-Referenzclient in deine App einbinden — drei Stellen:

// (1) ERSTE Zeile in Main — Selbst-Update-Helfer behandeln, dann normal weiter.
if ( Updater.TryRunUpdaterMode( args ) ) return;

// (2) Einmal konfigurieren (Server-URL an EINER Stelle halten).
var options = new LicenceOptions {
    ServerBaseUrl = "https://deine-server-adresse.example",
    ProductSlug   = "dein-produkt-slug",   // = Produkt-Slug auf dem Server
    AppVersion    = "1.0.0",               // installierte Version
};
var client  = new LicenceClient( options );
var updater = new Updater( options );

// (3) Aktivieren / prüfen / aktualisieren.
await client.ActivateAsync( key );                  // dieses Gerät aktivieren
var status = await client.ValidateAsync( key );     // status.FeaturesEnabled schaltet Premium frei (fail-open)
var update = await updater.CheckForUpdateAsync( key );
if ( update is not null ) {
    var paket = await updater.DownloadAndVerifyAsync( update );  // prüft SHA-256, wirft bei Manipulation
    updater.ApplyUpdateAndRestart( paket );                     // ersetzt die .exe und startet neu
}

Eine neue Version ausliefern? Im Produkt die Latest Version hochzählen, die neue .exe/.msi hochladen, speichern — den Rest erledigt der Server.

Wie das stille Update funktioniert

Eine laufende Single-File-.exe sperrt ihre eigene Datei und kann sich nicht selbst überschreiben. Deshalb: Der Client lädt die neue .exe, prüft ihre SHA-256– Prüfsumme, startet einen winzigen Austausch-Helfer, beendet die App — der Helfer wartet, ersetzt die Datei und startet sie neu. Updater.TryRunUpdaterMode(args) in der ersten Main-Zeile ist genau dieser Helfer. Eine .msi wird stattdessen still per msiexec installiert.

Gib das deiner KI

Kopiere den Block unten in ChatGPT oder Claude (zusammen mit deiner App) — die KI baut die Integration ein.

Kontext für die KI: Ich möchte meine Windows-/.NET-Desktop-App mit smartEngin Licence & buy lizenzieren und automatisch aktualisieren. Es gibt einen fertigen .NET/C#-Referenzclient (SmartEngin.Licence: LicenceClient + Updater), der über die REST-API sels/v1 mit dem Server spricht. Ein Lizenzschlüssel ist ein zufälliges, serverseitig gespeichertes Token; die Aktivierungs-Kennung ist eine anonyme Geräte-ID (instance_type=device). Der Client muss fail-open sein (Serverausfall darf die App nie lahmlegen) und Updates erst nach SHA-256-Prüfung installieren.

Tu Folgendes: (1) Updater.TryRunUpdaterMode(args) als erste Zeile in Main; (2) EINE LicenceOptions mit ServerBaseUrl, ProductSlug, AppVersion, die Server-URL an einer Stelle; (3) beim Start aktivieren/prüfen und Premium über status.FeaturesEnabled freischalten; (4) Update per CheckForUpdateAsync → DownloadAndVerifyAsync → ApplyUpdateAndRestart. Baue keinerlei Kopierschutz-Tricks ein.

Referenz (öffentlich, roh):
Windows-Anleitung: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/windows-software-guide.md
REST-Referenz: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/rest-reference.md
OpenAPI: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/openapi.yaml

Ehrlich zum Schluss: Code-Signing

Eine unsignierte .exe löst beim Kunden eine Windows-SmartScreen-Warnung aus. Fürs Testen egal; für den Verkauf signierst du deine .exe/.msi mit einem Authenticode-Zertifikat (~100–300 €/Jahr). Das ist unabhängig von der Lizenzierung — es geht nur darum, dass Windows deiner Herausgeber-Identität vertraut. Die Lizenzierung selbst ist eine Geschäftsmechanik, kein unknackbarer Kopierschutz: Die echte Durchsetzung liegt serverseitig (Update-Kanal, signierte Downloads, Aktivierungslimits). Halte den Client fail-open.

Für Entwickler: Python-Desktop-Apps verkaufen & aktualisieren (Windows · macOS · Linux)

Du baust deine App mit Python (z. B. Flask + pywebview, gepackt per PyInstaller)? Derselbe Server lizenziert und aktualisiert auch deine Python-App still im Hintergrund — genau wie bei WordPress und .NET. Ein fertiger, abhängigkeitsarmer Python-Referenzclient (se_licence.py, nur Standardbibliothek) übernimmt Aktivierung, ausfallsichere Prüfung und das stille Selbst-Update. Er ist das exakte Python-Pendant zum .NET-Client und läuft plattformübergreifend auf Windows, macOS und Linux.

Dieser Abschnitt ist für Python-Software außerhalb von WordPress. Für WordPress-Plugins siehe den obersten Abschnitt (build-freie PHP-Bibliothek), für .NET/C# den Abschnitt darüber.

Schnellstart (Python)

1. Produkt anlegen (Licence & buy → Products): Plattform auf Windows-App (.exe / .msi), einen Slug und eine Latest Version setzen, deine mit --onefile gebaute .exe als Paket hochladen.
2. se_licence.py und licence_config.py neben deine App legen — drei Stellen im Einstiegspunkt:

import sys, se_licence, licence_config

def main():
    # (1) ERSTE Zeile: als Update-Helfer gestartet? Datei tauschen und beenden.
    if se_licence.Updater.try_run_updater_mode( sys.argv ):
        return

    options = se_licence.LicenceOptions(
        server_url   = licence_config.SERVER_URL,    # deine Licence-&-buy-Server-Adresse
        product_slug = licence_config.PRODUCT_SLUG,  # = Produkt-Slug auf dem Server
        app_version  = licence_config.APP_VERSION,   # installierte Version, bei Release hochzählen
    )
    client  = se_licence.LicenceClient( options )
    updater = se_licence.Updater( options )
    slug    = licence_config.PRODUCT_SLUG

    # (2) Gesperrt bis zur ersten Aktivierung – danach fail-open.
    if not se_licence.is_licensed( slug ):
        key = frag_nutzer_nach_key()               # dein Fenster / deine Eingabe
        result = client.activate( key )
        if not result["success"]:
            zeige_fehler( result["message"] ); return
        se_licence.save_key( slug, key )           # Schlüssel merken – nie wieder fragen

    # (3) Prüfen (fail-open) + stilles Update, am besten im Hintergrund.
    key = se_licence.load_key( slug )
    client.validate( key )                         # frischt den Status auf; wirft nie
    info = updater.check_for_update( key )
    if info:
        paket = updater.download_and_verify( info )     # prüft SHA-256, wirft bei Manipulation
        updater.apply_update_and_restart( paket )       # ersetzt die .exe und startet neu

    starte_deine_app()

Premium-Funktionen schaltest du über das features_enabled-Feld aus client.validate(key) frei (fail-open — nur ein bestätigt erstatteter/deaktivierter Schlüssel schaltet ab). Eine neue Version ausliefern? Latest Version hochzählen, neue .exe hochladen, speichern — den Rest erledigt der Server.

Als eine .exe bauen

pyinstaller --onefile --windowed --name "MeineApp" app.py

Die Module se_licence/licence_config werden importiert und daher automatisch mitgepackt.

Wie das stille Update funktioniert

Eine laufende --onefile–.exe entpackt sich in einen Temp-Ordner und sperrt ihre eigene Datei — sie kann sich nicht selbst überschreiben. Deshalb: Der Client lädt die neue .exe, prüft ihre SHA-256-Prüfsumme, startet eine Kopie als Austausch-Helfer (--se-apply-update), beendet die App — der Helfer wartet auf das Prozess-Ende, ersetzt die Datei und startet sie neu. se_licence.Updater.try_run_updater_mode(sys.argv) in der ersten main()-Zeile ist genau dieser Helfer. Eine .msi wird stattdessen still per msiexec installiert.

Hinweis: Der In-Place-Tausch passt zu einer Single-File-.exe. Ein PyInstaller-Ordner-Build (--onedir) ist ein ganzes Verzeichnis und lässt sich nicht als eine Datei tauschen — nutze --onefile oder liefere einen Installer als Paket.

Läuft auf Windows, macOS & Linux

Derselbe Client-Code läuft auf allen drei Systemen — Datenordner, Prozess-Warten und Ausführbar-Bit werden je Betriebssystem passend gewählt. Im Produkt wählst du dafür die Plattform „macOS / Linux / other“.

• Linux: ein --onefile-Binary oder eine Einzeldatei-AppImage aktualisiert sich genau wie die Windows-.exe. (Ein .deb/.rpm ist ein System-Paket — das aktualisiert der Paketmanager.)
• macOS: eine Einzeldatei genauso; ein echtes .app-Bündel ist ein Ordner und braucht stattdessen einen signierten, notariellen Installer (.dmg/.pkg).

Der Lizenz-Teil (Aktivieren/Prüfen, fail-open) ist auf jedem System identisch — nur die Verpackung des Updates unterscheidet sich. Details im Python-Guide auf GitHub.

Gib das deiner KI

Kopiere den Block unten in ChatGPT oder Claude (zusammen mit deiner App) — die KI baut die Integration ein.

Kontext für die KI: Ich möchte meine Python-Desktop-App mit smartEngin Licence & buy lizenzieren und automatisch aktualisieren. Es gibt einen fertigen, abhängigkeitsarmen Python-Referenzclient (se_licence.py: LicenceClient + Updater + is_licensed/save_key/load_key), der über die REST-API sels/v1 mit dem Server spricht. Ein Lizenzschlüssel ist ein zufälliges, serverseitig gespeichertes Token; die Aktivierungs-Kennung ist eine anonyme Geräte-ID (instance_type=device). Der Client muss fail-open sein (Serverausfall darf die App nie lahmlegen) und Updates erst nach SHA-256-Prüfung installieren.

Tu Folgendes: (1) se_licence.Updater.try_run_updater_mode(sys.argv) als erste Zeile in main(); (2) EINE LicenceOptions mit server_url, product_slug, app_version, Server-URL an einer Stelle eingebacken; (3) App ohne gültigen Key sperren — bei fehlendem Schlüssel nur ein Key-Eingabefenster, client.activate, dann save_key; danach fail-open; (4) Premium über features_enabled freischalten; (5) Update per check_for_update → download_and_verify → apply_update_and_restart. Bau mit pyinstaller --onefile --windowed. Baue keinerlei Kopierschutz-Tricks ein.

Referenz (öffentlich, roh):
Python-Anleitung: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/python-software-guide.md
REST-Referenz: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/rest-reference.md
OpenAPI: https://raw.githubusercontent.com/smartengin-de/smartengin-licence-client/main/docs/openapi.yaml

Ehrlich zum Schluss: Code-Signing

Eine unsignierte .exe löst beim Kunden eine Windows-SmartScreen-Warnung aus. Fürs Testen egal; für den Verkauf signierst du deine .exe mit einem Authenticode-Zertifikat (~100–300 €/Jahr). Das ist unabhängig von der Lizenzierung — es geht nur darum, dass Windows deiner Herausgeber-Identität vertraut. Die Lizenzierung selbst ist eine Geschäftsmechanik, kein unknackbarer Kopierschutz: Die echte Durchsetzung liegt serverseitig (Update-Kanal, signierte Downloads, Aktivierungslimits). Halte den Client fail-open.