layoutbridge-light 0.0.0-stage → 1.0.1

package/dist/src/mcp/license/gate.js

@@ -0,0 +1,210 @@
+/**
+ * Das Gate (E-60): entscheidet je Aufruf, ob ein Werkzeug laufen darf.
+ *
+ * Reihenfolge: Schranke aus -> frei; Werkzeug auf der Freiliste -> frei;
+ * kein Schluessel -> gesperrt; gespeichertes gueltiges Ergebnis zum selben
+ * Schluessel, juenger als das Nachpruefintervall und nicht abgelaufen ->
+ * frei; sonst Pruefung ueber den Verifier: gueltig -> speichern, frei;
+ * ungueltig/abgelaufen/falsches Produkt -> speichern, gesperrt; nicht
+ * erreichbar -> frei mit Warnung, solange die Kulanzfrist ab der letzten
+ * gueltigen Pruefung laeuft, sonst gesperrt. Gleichzeitige Aufrufe teilen
+ * sich eine laufende Pruefung.
+ */
+import { transportError } from '../../transport/transport.js';
+import { LICENSE_TERMS_URL, LICENSE_TERMS_URL_DE, SUPPORT_EMAIL, withSupportHint } from '../product-info.js';
+import { fingerprint } from './key-source.js';
+import { envName } from '../product.js';
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+/** Nach so langer Zeit wird ein gueltiges Ergebnis erneut geprueft. */
+export const RECHECK_INTERVAL_MS = 24 * HOUR_MS;
+/** So lange gilt ein gueltiges Ergebnis weiter, wenn der Dienst nicht erreichbar ist. */
+export const GRACE_PERIOD_MS = 14 * DAY_MS;
+/** Nach einem "nicht erreichbar" wird fruehestens nach dieser Zeit erneut angefragt. */
+export const RETRY_INTERVAL_MS = 1 * HOUR_MS;
+function isoOrNull(ms) {
+    return ms === null ? null : new Date(ms).toISOString();
+}
+function parseMs(value) {
+    if (value === null || value === undefined)
+        return null;
+    const ms = Date.parse(value);
+    return Number.isNaN(ms) ? null : ms;
+}
+export class LicenseGate {
+    enforce;
+    verifier;
+    store;
+    lookupKey;
+    isFree;
+    context;
+    now;
+    recheckIntervalMs;
+    gracePeriodMs;
+    retryIntervalMs;
+    pending = null;
+    constructor(options) {
+        this.enforce = options.enforce;
+        this.verifier = options.verifier;
+        this.store = options.store;
+        this.lookupKey = options.lookupKey;
+        this.isFree = options.isFree;
+        this.context = options.context;
+        this.now = options.now ?? (() => new Date());
+        this.recheckIntervalMs = options.recheckIntervalMs ?? RECHECK_INTERVAL_MS;
+        this.gracePeriodMs = options.gracePeriodMs ?? GRACE_PERIOD_MS;
+        this.retryIntervalMs = options.retryIntervalMs ?? RETRY_INTERVAL_MS;
+    }
+    /**
+     * Eine Zeile fuer die Startmeldung des Servers. "off" kommt seit A-9
+     * (E-86) im laufenden Server nicht mehr vor – nur bei einem im Code mit
+     * `enforce: false` gebauten Gate.
+     */
+    describe() {
+        if (!this.enforce) {
+            return `license: off, verifier: ${this.verifierLabel()}`;
+        }
+        const lookup = this.lookupKey();
+        let key = 'none (' + lookup.path + ')';
+        if (lookup.source === 'env')
+            key = 'env';
+        if (lookup.source === 'file')
+            key = 'file ' + lookup.path;
+        return `license: enforced, verifier: ${this.verifierLabel()}, key: ${key}, state: ${this.store.location}`;
+    }
+    /** Verifier mit seinen Einstellungen, wenn er sie selbst beschreibt. */
+    verifierLabel() {
+        const describe = this.verifier.describe;
+        return typeof describe === 'function' ? describe.call(this.verifier) : this.verifier.name;
+    }
+    /**
+     * Fehlerumschlag fuer eine Sperre. Jede Meldung der Fehlerart `license`
+     * nennt die Support-Adresse im Klartext (A-10 Nr. 1); `details` traegt
+     * zusaetzlich `support` und die Adresse der Lizenzbedingungen (A-11
+     * Nr. 3) – additiv, der Aufbau der Fehlerantwort bleibt (A-5).
+     */
+    toError(decision) {
+        return transportError('license', withSupportHint(decision.message ?? 'Licence check failed.'), {
+            ...decision.details,
+            support: SUPPORT_EMAIL,
+            license_terms: LICENSE_TERMS_URL,
+            license_terms_de: LICENSE_TERMS_URL_DE,
+        });
+    }
+    async decide(toolName, readOnly) {
+        if (!this.enforce)
+            return { allowed: true, status: 'off', message: null, details: {} };
+        if (this.isFree(toolName, readOnly))
+            return { allowed: true, status: 'free', message: null, details: {} };
+        const lookup = this.lookupKey();
+        if (lookup.key === null) {
+            return this.locked('missing', 'No licence key found. Set ' + envName('LICENSE_KEY') + ' or put the key into ' + lookup.path + '.', lookup, null);
+        }
+        const fp = fingerprint(lookup.key);
+        const nowMs = this.now().getTime();
+        const stored = this.store.load();
+        const same = stored !== null && stored.key_fingerprint === fp ? stored : null;
+        if (same !== null) {
+            const checkedMs = parseMs(same.checked_at) ?? 0;
+            const expiresMs = parseMs(same.expires_at);
+            const notExpired = expiresMs === null || expiresMs > nowMs;
+            if (same.status === 'valid' && notExpired && nowMs - checkedMs < this.recheckIntervalMs) {
+                return this.allowed('valid', null, lookup, same);
+            }
+            if (same.status === 'unreachable' && nowMs - checkedMs < this.retryIntervalMs) {
+                return this.afterUnreachable(same, lookup, nowMs, same.message);
+            }
+        }
+        if (this.pending !== null && this.pending.fingerprint === fp)
+            return this.pending.promise;
+        const promise = this.verify(lookup, fp, same).finally(() => {
+            this.pending = null;
+        });
+        this.pending = { fingerprint: fp, promise };
+        return promise;
+    }
+    async verify(lookup, fp, same) {
+        const key = lookup.key;
+        const context = { ...this.context, instance_id: same?.instance_id ?? null };
+        let outcome;
+        try {
+            outcome = await this.verifier.verify(key, context);
+        }
+        catch (error) {
+            outcome = { status: 'unreachable', message: 'Licence check failed: ' + String(error) };
+        }
+        const nowMs = this.now().getTime();
+        const checkedAt = new Date(nowMs).toISOString();
+        if (outcome.status === 'valid') {
+            const state = {
+                key_fingerprint: fp,
+                status: 'valid',
+                checked_at: checkedAt,
+                last_valid_at: checkedAt,
+                expires_at: outcome.expires_at ?? null,
+                instance_id: outcome.instance_id ?? same?.instance_id ?? null,
+                verifier: this.verifier.name,
+                message: outcome.message,
+            };
+            this.store.save(state);
+            return this.allowed('valid', null, lookup, state);
+        }
+        const state = {
+            key_fingerprint: fp,
+            status: outcome.status,
+            checked_at: checkedAt,
+            last_valid_at: same?.last_valid_at ?? null,
+            expires_at: outcome.expires_at ?? same?.expires_at ?? null,
+            instance_id: same?.instance_id ?? null,
+            verifier: this.verifier.name,
+            message: outcome.message,
+        };
+        this.store.save(state);
+        if (outcome.status === 'unreachable')
+            return this.afterUnreachable(state, lookup, nowMs, outcome.message);
+        return this.locked(outcome.status, this.describeRefusal(outcome.status, outcome.message, state), lookup, state);
+    }
+    /** Dienst nicht erreichbar: Kulanzfrist ab der letzten gueltigen Pruefung. */
+    afterUnreachable(state, lookup, nowMs, reason) {
+        const anchorMs = parseMs(state.last_valid_at);
+        const expiresMs = parseMs(state.expires_at);
+        if (expiresMs !== null && expiresMs <= nowMs) {
+            return this.locked('expired', 'The licence expired on ' + state.expires_at + ' and could not be re-verified: ' + reason, lookup, state);
+        }
+        if (anchorMs === null) {
+            return this.locked('unverified', 'The licence key could not be verified and no earlier valid check is stored: ' + reason, lookup, state);
+        }
+        const graceUntilMs = anchorMs + this.gracePeriodMs;
+        if (nowMs <= graceUntilMs) {
+            return this.allowed('grace', 'Licence not verified online since ' + state.last_valid_at + '; the grace period ends ' + isoOrNull(graceUntilMs) + '.', lookup, state, graceUntilMs);
+        }
+        return this.locked('unverified', 'The licence key could not be verified and the grace period ended ' + isoOrNull(graceUntilMs) + ': ' + reason, lookup, state);
+    }
+    describeRefusal(status, message, state) {
+        if (status === 'expired')
+            return 'The licence expired' + (state.expires_at ? ' on ' + state.expires_at : '') + '. ' + message;
+        if (status === 'invalid')
+            return 'The licence key is not valid. ' + message;
+        if (status === 'product_mismatch')
+            return 'The licence key belongs to another product or major version. ' + message;
+        return message;
+    }
+    details(lookup, state, graceUntilMs) {
+        return {
+            key_source: lookup.source,
+            key_path: lookup.path,
+            checked_at: state?.checked_at ?? null,
+            last_valid_at: state?.last_valid_at ?? null,
+            expires_at: state?.expires_at ?? null,
+            grace_until: isoOrNull(graceUntilMs),
+            verifier: this.verifier.name,
+        };
+    }
+    allowed(status, message, lookup, state, graceUntilMs = null) {
+        return { allowed: true, status, message, details: { status, ...this.details(lookup, state, graceUntilMs) } };
+    }
+    locked(status, message, lookup, state) {
+        return { allowed: false, status, message: withSupportHint(message), details: { status, ...this.details(lookup, state, null) } };
+    }
+}
+//# sourceMappingURL=gate.js.map

package/dist/src/mcp/license/index.js

@@ -0,0 +1,107 @@
+/**
+ * Zusammenbau der Lizenzschranke fuer den laufenden Server (E-60, E-62).
+ *
+ * Seit der Ergaenzung des Auftrags A-6 (06.09.2026) prueft der Verifier des
+ * Zahlungsdienstes; die Attrappe bleibt fuer Tests. Scharfschalten in zwei
+ * Stufen (Ergaenzung Nr. 10): Stufe 1 hielt die Schranke im laufenden
+ * Server aus, scharf nur mit LAYOUTBRIDGE_SPM_LICENSE_ENFORCE=1. Seit
+ * Stufe 2 (A-9 fuer Polar, E-86, 23.09.2026) ist sie immer scharf; die
+ * Umgebungsvariable ist entfallen und wird nicht mehr gelesen. Aus ist die
+ * Schranke nur noch, wenn ein LicenseGate im Code mit `enforce: false`
+ * gebaut wird (Einheitstests) – kein Schalter von aussen.
+ */
+import { isFreeTool } from './free-tools.js';
+import { LicenseGate } from './gate.js';
+import { resolveInstanceName } from './instance-name.js';
+import { defaultLicenseStatePath, readLicenseKey } from './key-source.js';
+import { LemonSqueezyVerifier } from './lemonsqueezy-verifier.js';
+import { resolvePolarIds } from './polar-ids.js';
+import { PolarVerifier, resolvePolarBaseUrl } from './polar-verifier.js';
+import { resolveProductIds } from './product-ids.js';
+import { FileLicenseStateStore } from './state-store.js';
+import { paymentPrivacyPolicyUrlFor, withSupportHint } from '../product-info.js';
+import { envName, PRODUCT } from '../product.js';
+export { LicenseGate } from './gate.js';
+/**
+ * Welcher Zahlungsdienst geprueft wird (A-15 Nr. 3, 23.09.2026; A-15a Nr. 1).
+ *
+ * Vorgabe ist seit A-15a polar (Entscheidung des Anbieters, 23.09.2026: Polar zum
+ * Verkaufsstart). Die Klasse lemonsqueezy bleibt als Rueckfall; umgeschaltet
+ * wird allein in der Bauphase ueber die Umgebungsvariable, in beide
+ * Richtungen – kein Kundenschalter, nichts aus config.json.
+ */
+export const DEFAULT_LICENSE_PROVIDER = 'polar';
+export const LICENSE_PROVIDER_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_PROVIDER';
+/**
+ * LayoutBridge Light kennt nur Polar (E-109): kein Rueckfall auf
+ * lemonsqueezy, auch nicht ueber die Umgebungsvariable.
+ */
+export function resolveLicenseProvider(env = process.env, product = PRODUCT) {
+    if (product.id === 'light')
+        return 'polar';
+    const value = env[envName('LICENSE_PROVIDER', product)];
+    return value === 'polar' || value === 'lemonsqueezy' ? value : DEFAULT_LICENSE_PROVIDER;
+}
+export function createVerifier(env = process.env, product = PRODUCT) {
+    if (resolveLicenseProvider(env, product) === 'polar') {
+        return new PolarVerifier({
+            ids: resolvePolarIds(env, undefined, product),
+            baseUrl: resolvePolarBaseUrl(env, product),
+            requireBenefit: product.id === 'light',
+        });
+    }
+    return new LemonSqueezyVerifier({ productIds: resolveProductIds(env, undefined, product) });
+}
+/** Datenschutzerklaerung des gewaehlten Zahlungsdienstes (A-15 Nr. 5). */
+export function paymentPrivacyPolicyUrl(env = process.env, product = PRODUCT) {
+    return paymentPrivacyPolicyUrlFor(resolveLicenseProvider(env, product));
+}
+export function createLicenseGate(options) {
+    const env = options.env ?? process.env;
+    return new LicenseGate({
+        enforce: true,
+        verifier: createVerifier(env),
+        store: new FileLicenseStateStore(defaultLicenseStatePath(env)),
+        lookupKey: () => readLicenseKey(env),
+        isFree: isFreeTool,
+        context: {
+            product: options.product,
+            product_version: options.version.split('.')[0] ?? options.version,
+            instance_name: resolveInstanceName(env),
+        },
+    });
+}
+/**
+ * Rechnerwechsel (Ergaenzung Nr. 7): die Aktivierung dieses Arbeitsplatzes
+ * beim Dienst freigeben und den lokalen Speicher loeschen. Laeuft ohne
+ * InDesign und ohne Client – der Server wird dafuer mit --deactivate
+ * aufgerufen. Bewusst kein Werkzeug im Katalog: die Schnittstelle bleibt
+ * unveraendert (A-5), und eine KI kann den Vorgang nicht beilaeufig
+ * ausloesen.
+ */
+export async function runDeactivation(env = process.env, verifier = createVerifier(env), store = new FileLicenseStateStore(defaultLicenseStatePath(env))) {
+    const lookup = readLicenseKey(env);
+    if (lookup.key === null) {
+        return { ok: false, message: 'No licence key found. Set ' + envName('LICENSE_KEY') + ' or put the key into ' + lookup.path + '.' };
+    }
+    const state = store.load();
+    if (state === null || state.instance_id === null) {
+        store.clear();
+        return {
+            ok: true,
+            message: 'No activation was stored for this machine; the local licence state has been removed. Nothing had to be released at the service.',
+        };
+    }
+    if (verifier.deactivate === undefined) {
+        return { ok: false, message: withSupportHint('This build cannot release an activation.') };
+    }
+    try {
+        await verifier.deactivate(lookup.key, state.instance_id);
+    }
+    catch (error) {
+        return { ok: false, message: withSupportHint('The activation was not released: ' + String(error instanceof Error ? error.message : error)) };
+    }
+    store.clear();
+    return { ok: true, message: 'The activation was released and the local licence state removed. The key can now be activated on another machine.' };
+}
+//# sourceMappingURL=index.js.map

package/dist/src/mcp/license/instance-name.js

@@ -0,0 +1,57 @@
+/**
+ * Instanzname fuer die Aktivierung beim Zahlungsdienst (Auftrag A-8 des
+ * Vermarktungsprojekts, 13.09.2026, Vermerk E-64).
+ *
+ * Frueher war das der Rechnername (`hostname()`). Der kann einen
+ * Personennamen enthalten und verliess damit bei jeder Aktivierung den
+ * Rechner. Stattdessen jetzt eine zufaellige Kennung `layoutbridge-<8
+ * Hexzeichen>`, die beim ersten Mal erzeugt und neben der Lizenzdatei
+ * abgelegt wird; danach ist sie ueber Neustarts hinweg dieselbe.
+ * LAYOUTBRIDGE_SPM_INSTANCE_NAME ueberschreibt sie, fuer alle, die im
+ * Haendler-Dashboard lesbare Namen wollen.
+ */
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { dirname } from 'node:path';
+import { defaultLicenseDirectory, licensePathApi } from './key-source.js';
+import { envName, PRODUCT } from '../product.js';
+/** Form der erzeugten Kennung. */
+export const INSTANCE_NAME_PATTERN = /^layoutbridge-[0-9a-f]{8}$/;
+export function defaultInstanceNamePath(os = platform(), home = homedir(), product = PRODUCT) {
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home, product), 'instance-name');
+}
+/** Eine neue Zufallskennung bilden. */
+export function newInstanceName(random = randomBytes) {
+    return 'layoutbridge-' + random(4).toString('hex');
+}
+/**
+ * Die Kennung dieses Arbeitsplatzes: Umgebungsvariable, sonst die
+ * gespeicherte, sonst eine neue. Laesst sich die neue nicht speichern,
+ * wird sie trotzdem verwendet – die Aktivierung soll an einer nicht
+ * schreibbaren Datei nicht scheitern; der Hinweis geht auf die
+ * Standardfehlerausgabe.
+ */
+export function resolveInstanceName(env = process.env, path = defaultInstanceNamePath(), product = PRODUCT) {
+    const fromEnv = env[envName('INSTANCE_NAME', product)];
+    if (fromEnv !== undefined && fromEnv.trim().length > 0)
+        return fromEnv.trim();
+    try {
+        const stored = readFileSync(path, 'utf8').trim();
+        if (INSTANCE_NAME_PATTERN.test(stored))
+            return stored;
+    }
+    catch {
+        /* keine Datei oder nicht lesbar – dann eine neue Kennung */
+    }
+    const created = newInstanceName();
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, created + '\n', { encoding: 'utf8', mode: 0o600 });
+    }
+    catch (error) {
+        process.stderr.write(`[${product.packageName}] cannot store the instance name: ${String(error)}\n`);
+    }
+    return created;
+}
+//# sourceMappingURL=instance-name.js.map

package/dist/src/mcp/license/key-source.js

@@ -0,0 +1,59 @@
+/**
+ * Schluesselquelle (E-60): Umgebungsvariable LAYOUTBRIDGE_SPM_LICENSE_KEY,
+ * sonst die Datei aus LAYOUTBRIDGE_SPM_LICENSE_FILE, sonst die Vorgabedatei
+ * neben der Serverkonfiguration. Wird bei jedem Aufruf gelesen, der eine
+ * Pruefung braucht – ein nachgelegter Schluessel wirkt ohne Neustart.
+ */
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { posix, win32 } from 'node:path';
+import { envName, PRODUCT } from '../product.js';
+/**
+ * Pfadregeln der Zielplattform, nicht des Wirtsrechners (Sitzung 25): so
+ * liefert ein Aufruf fuer 'darwin' auch unter Windows Schraegstriche und
+ * einer fuer 'win32' auch am Mac Backslashes – wie setupLicenseKeyPath in
+ * setup.ts. Im Betrieb ist die Plattform der Wirt; das Ergebnis bleibt gleich.
+ */
+export function licensePathApi(os) {
+    return os === 'win32' ? win32 : posix;
+}
+export function defaultLicenseDirectory(os = platform(), home = homedir(), product = PRODUCT) {
+    const p = licensePathApi(os);
+    if (os === 'darwin')
+        return p.join(home, 'Library', 'Application Support', product.dataDirName);
+    return p.join(home, '.' + product.dataDirName);
+}
+export function defaultLicenseKeyPath(env = process.env, os = platform(), home = homedir(), product = PRODUCT) {
+    const fromEnv = env[envName('LICENSE_FILE', product)];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home, product), 'license.key');
+}
+export function defaultLicenseStatePath(env = process.env, os = platform(), home = homedir(), product = PRODUCT) {
+    const fromEnv = env[envName('LICENSE_STATE', product)];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home, product), 'license-state.json');
+}
+/** Kurzer Fingerabdruck fuer Speicher und Protokoll – nie der Schluessel selbst. */
+export function fingerprint(key) {
+    return createHash('sha256').update(key, 'utf8').digest('hex').slice(0, 16);
+}
+/** Schluessel suchen. Leere Werte zaehlen als nicht vorhanden. */
+export function readLicenseKey(env = process.env, path = defaultLicenseKeyPath(env), product = PRODUCT) {
+    const fromEnv = env[envName('LICENSE_KEY', product)];
+    if (fromEnv !== undefined && fromEnv.trim().length > 0) {
+        return { key: fromEnv.trim(), source: 'env', path };
+    }
+    try {
+        const text = readFileSync(path, 'utf8').trim();
+        if (text.length > 0)
+            return { key: text, source: 'file', path };
+    }
+    catch {
+        /* keine Datei oder nicht lesbar = kein Schluessel */
+    }
+    return { key: null, source: null, path };
+}
+//# sourceMappingURL=key-source.js.map

package/dist/src/mcp/license/lemonsqueezy-verifier.js

@@ -0,0 +1,207 @@
+/**
+ * Prueffunktion des Zahlungsdienstes (A-6 Ergaenzung 06.09.2026).
+ *
+ * Drei Endpunkte der License API, alle ohne API-Schluessel und damit ohne
+ * Geheimnis im Connector: activate, validate, deactivate. Kein SDK, keine
+ * neue Laufzeitabhaengigkeit – der Aufruf geht ueber fetch aus Node ab
+ * Version 20.
+ *
+ * Aufrufmuster (Ergaenzung Nr. 4): ohne gespeicherte Instanzkennung
+ * aktivieren, sonst pruefen; meldet die Pruefung fuer die gespeicherte
+ * Instanz keinen Erfolg und ist der Schluessel selbst weder abgelaufen noch
+ * gesperrt (Instanz beim Haendler entfernt), genau einmal neu aktivieren.
+ *
+ * Der Lizenzschluessel erscheint nie in einer Meldung: was der Dienst
+ * zurueckschreibt, wird vor der Weitergabe um den Schluessel bereinigt.
+ */
+import { describeProductIds, productIdsConfigured, } from './product-ids.js';
+import { SUPPORT_EMAIL } from '../product-info.js';
+export const DEFAULT_BASE_URL = 'https://api.lemonsqueezy.com';
+export const DEFAULT_TIMEOUT_MS = 10_000;
+function record(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function text(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function numberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+/** Den Schluessel aus jedem Text entfernen, der nach aussen geht. */
+export function redactKey(message, key) {
+    if (key.length === 0)
+        return message;
+    return message.split(key).join('<key>');
+}
+export class LemonSqueezyVerifier {
+    name = 'lemonsqueezy';
+    productIds;
+    baseUrl;
+    timeoutMs;
+    fetchImpl;
+    now;
+    constructor(options) {
+        this.productIds = options.productIds;
+        this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+        this.now = options.now ?? (() => new Date());
+    }
+    /** Eine Zeile fuer die Startmeldung des Servers. */
+    describe() {
+        return `${this.name} (${this.baseUrl}, product ids: ${describeProductIds(this.productIds)})`;
+    }
+    async verify(key, context) {
+        if (context.instance_id === null) {
+            return this.interpret(await this.call('activate', { license_key: key, instance_name: context.instance_name }), key);
+        }
+        const validated = await this.call('validate', { license_key: key, instance_id: context.instance_id });
+        const outcome = this.interpret(validated, key, context.instance_id);
+        if (outcome.status !== 'invalid' || !this.instanceLikelyGone(validated))
+            return outcome;
+        /* Instanz beim Haendler entfernt: genau ein Aktivierungsversuch. */
+        return this.interpret(await this.call('activate', { license_key: key, instance_name: context.instance_name }), key);
+    }
+    async deactivate(key, instanceId) {
+        const answer = await this.call('deactivate', { license_key: key, instance_id: instanceId });
+        if (answer.body === null) {
+            throw new Error('The licence service could not be reached: ' + answer.reason);
+        }
+        if (answer.body['deactivated'] !== true) {
+            const reason = text(answer.body['error']) ?? 'the service refused the deactivation';
+            throw new Error(redactKey(reason, key));
+        }
+    }
+    /**
+     * Der Schluessel selbst ist noch brauchbar, nur die Instanz nicht mehr:
+     * Antwort auswertbar, ein license_key-Block vorhanden, dessen Zustand
+     * weder abgelaufen noch gesperrt ist.
+     */
+    instanceLikelyGone(answer) {
+        if (answer.body === null)
+            return false;
+        /* Live-Befund 15.09.2026 (Test-Store): bei unbekannter Instanz antwortet
+           der Dienst mit HTTP 404 {"valid":false,"error":"instance_id not found."}
+           - ohne license_key-Block. Der Wortlaut allein genuegt dann. */
+        const serviceError = text(answer.body['error']);
+        if (serviceError !== null && /\binstance(_id)?\b[^.]*not found/i.test(serviceError))
+            return true;
+        const licenseKey = record(answer.body['license_key']);
+        if (licenseKey === null)
+            return false;
+        const status = text(licenseKey['status']);
+        return status !== 'expired' && status !== 'disabled';
+    }
+    async call(endpoint, fields) {
+        const body = new URLSearchParams(fields).toString();
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.baseUrl}/v1/licenses/${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body,
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (error) {
+            return { body: null, httpStatus: null, reason: 'request failed (' + String(error) + ')' };
+        }
+        const httpStatus = response.status;
+        if (httpStatus >= 500 || httpStatus === 429) {
+            return { body: null, httpStatus, reason: 'the service answered HTTP ' + httpStatus };
+        }
+        let parsed;
+        try {
+            parsed = await response.json();
+        }
+        catch {
+            return { body: null, httpStatus, reason: 'the answer was not readable JSON (HTTP ' + httpStatus + ')' };
+        }
+        const asRecord = record(parsed);
+        if (asRecord === null) {
+            return { body: null, httpStatus, reason: 'the answer was not a JSON object (HTTP ' + httpStatus + ')' };
+        }
+        return { body: asRecord, httpStatus, reason: '' };
+    }
+    /** Antwort des Dienstes auf die Ergebnisse aus S11 abbilden. */
+    interpret(answer, key, storedInstanceId = null) {
+        if (answer.body === null) {
+            return { status: 'unreachable', message: 'The licence service could not be reached: ' + answer.reason };
+        }
+        const body = answer.body;
+        const serviceError = text(body['error']);
+        const licenseKey = record(body['license_key']);
+        const meta = record(body['meta']);
+        const instance = record(body['instance']);
+        const expiresAt = licenseKey === null ? null : text(licenseKey['expires_at']);
+        const instanceId = (instance === null ? null : text(instance['id'])) ?? storedInstanceId;
+        /* 1. Produkt vor allem anderen – auch wenn der Dienst "gueltig" sagt. */
+        const mismatch = this.productMismatch(meta);
+        if (mismatch !== null) {
+            return this.outcome('product_mismatch', mismatch, key, expiresAt, instanceId);
+        }
+        /* 2. Abgelaufen. */
+        const status = licenseKey === null ? null : text(licenseKey['status']);
+        if (status === 'expired' || this.expiryPassed(expiresAt)) {
+            const reason = serviceError ?? 'The licence has expired.';
+            return this.outcome('expired', reason, key, expiresAt, instanceId);
+        }
+        /* 3. Erfolg. */
+        const succeeded = body['activated'] === true || body['valid'] === true;
+        if (succeeded && status === 'active') {
+            return this.outcome('valid', 'The licence key is valid.', key, expiresAt, instanceId);
+        }
+        /* 4. Alles Uebrige. */
+        let reason = serviceError ?? 'The service did not confirm the licence key (HTTP ' + String(answer.httpStatus) + ').';
+        if (serviceError !== null && serviceError.toLowerCase().includes('activation limit')) {
+            reason +=
+                ' Release the licence on the machine that uses it (run the server with --deactivate there) or ask LayoutBridge support (' + SUPPORT_EMAIL + ') to free the activation.';
+        }
+        else if (succeeded && status !== 'active') {
+            reason = 'The service confirmed the key but reports the state "' + String(status) + '".';
+        }
+        return this.outcome('invalid', reason, key, expiresAt, instanceId);
+    }
+    outcome(status, message, key, expiresAt, instanceId) {
+        return {
+            status,
+            message: redactKey(message, key),
+            expires_at: expiresAt,
+            instance_id: instanceId,
+        };
+    }
+    expiryPassed(expiresAt) {
+        if (expiresAt === null)
+            return false;
+        const ms = Date.parse(expiresAt);
+        if (Number.isNaN(ms))
+            return false;
+        return ms <= this.now().getTime();
+    }
+    /** null = in Ordnung; sonst der Klartext der Abweichung. */
+    productMismatch(meta) {
+        if (!productIdsConfigured(this.productIds))
+            return null;
+        if (meta === null)
+            return null;
+        const storeId = numberOrNull(meta['store_id']);
+        const productId = numberOrNull(meta['product_id']);
+        const variantId = numberOrNull(meta['variant_id']);
+        if (this.productIds.store_id !== null && storeId !== this.productIds.store_id) {
+            return 'The licence key belongs to another store.';
+        }
+        if (this.productIds.product_id !== null && productId !== this.productIds.product_id) {
+            return 'The licence key belongs to another product.';
+        }
+        if (this.productIds.variant_ids.length > 0 && (variantId === null || !this.productIds.variant_ids.includes(variantId))) {
+            return 'The licence key belongs to another product variant.';
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=lemonsqueezy-verifier.js.map

package/dist/src/mcp/license/placeholder-verifier.js

@@ -0,0 +1,10 @@
+export class PlaceholderVerifier {
+    name = 'placeholder';
+    async verify(_key, _context) {
+        return {
+            status: 'unreachable',
+            message: 'No licence service is wired into this build; the key cannot be verified online.',
+        };
+    }
+}
+//# sourceMappingURL=placeholder-verifier.js.map