layoutbridge-spm 0.0.1 → 1.0.0

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

@@ -0,0 +1,58 @@
+/**
+ * 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';
+/**
+ * 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()) {
+    const p = licensePathApi(os);
+    if (os === 'darwin')
+        return p.join(home, 'Library', 'Application Support', 'layoutbridge-spm');
+    return p.join(home, '.layoutbridge-spm');
+}
+export function defaultLicenseKeyPath(env = process.env, os = platform(), home = homedir()) {
+    const fromEnv = env['LAYOUTBRIDGE_SPM_LICENSE_FILE'];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home), 'license.key');
+}
+export function defaultLicenseStatePath(env = process.env, os = platform(), home = homedir()) {
+    const fromEnv = env['LAYOUTBRIDGE_SPM_LICENSE_STATE'];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home), '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)) {
+    const fromEnv = env['LAYOUTBRIDGE_SPM_LICENSE_KEY'];
+    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

package/dist/src/mcp/license/polar-ids.js

@@ -0,0 +1,63 @@
+/**
+ * Hinterlegte Kennungen des Zahlungsdienstes Polar (Auftrag A-15 Nr. 2,
+ * 23.09.2026).
+ *
+ * Polar arbeitet mit UUIDs statt Zahlen: die Organisation
+ * (organization_id) gehoert in jeden Aufruf, der Benefit (benefit_id)
+ * benennt den Lizenzschluessel-Vorteil des Produkts. Store, Produkt und
+ * Variante wie bei lemonsqueezy gibt es hier nicht; die Kennungen von
+ * lemonsqueezy in product-ids.ts bleiben davon unberuehrt.
+ *
+ * Hinterlegt sind die Kennungen des Live-Kontos (Organisation "MCP
+ * Interfaces"), wie sie das Auftragsdokument unter A-15a Teil 2
+ * (23.09.2026, 07:14 Uhr) nennt: organization_id aus Settings >
+ * Preferences (Feld "Identifier"), benefit_id aus der Adresse der
+ * Benefit-Seite (Vermerk E-85). Bestaetigt durch die erste validate-Antwort
+ * mit dem Live-Schluessel fuer Saschas Arbeitsplatz (Nachtrag 23.09.2026,
+ * 08:29 Uhr) und die Live-Probe von A-9 (Vermerk E-86): beide Werte
+ * stimmen mit der Antwort ueberein.
+ *
+ * Fuer die Sandbox-Probe lassen sie sich von aussen ueberschreiben – ueber
+ * Umgebungsvariablen und ausschliesslich in der Bauphase, nie ueber
+ * config.json: config.json ist Kundenkonfiguration und koennte damit den
+ * Produktabgleich aushebeln.
+ */
+/** Kennungen des Live-Kontos (A-15a Teil 2, 23.09.2026). */
+export const POLAR_IDS = {
+    organization_id: 'e8d80621-fb90-45e2-b0b6-73a94271fe18',
+    benefit_id: 'e9b61756-779b-4d65-83b9-f398346f6184',
+};
+/** Name der Umgebungsvariablen der Bauphase. */
+export const POLAR_ORG_ID_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_ORG_ID';
+export const POLAR_BENEFIT_ID_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_BENEFIT_ID';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Nur eine UUID zaehlt als Kennung; alles andere gilt als nicht gesetzt. */
+function uuidFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const trimmed = value.trim();
+    if (!UUID.test(trimmed))
+        return null;
+    return trimmed.toLowerCase();
+}
+/**
+ * Kennungen fuer diesen Lauf: die hinterlegten Konstanten, einzeln
+ * ueberschreibbar durch Umgebungsvariablen der Bauphase.
+ */
+export function resolvePolarIds(env = process.env, base = POLAR_IDS) {
+    return {
+        organization_id: uuidFromEnv(env[POLAR_ORG_ID_ENV]) ?? base.organization_id,
+        benefit_id: uuidFromEnv(env[POLAR_BENEFIT_ID_ENV]) ?? base.benefit_id,
+    };
+}
+/** Ist ueberhaupt eine Kennung hinterlegt? */
+export function polarIdsConfigured(ids) {
+    return ids.organization_id !== null || ids.benefit_id !== null;
+}
+/** Kurzfassung fuer Startzeile und Protokoll. */
+export function describePolarIds(ids) {
+    if (!polarIdsConfigured(ids))
+        return 'not set';
+    return `organization ${ids.organization_id ?? '-'}, benefit ${ids.benefit_id ?? '-'}`;
+}
+//# sourceMappingURL=polar-ids.js.map

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

@@ -0,0 +1,265 @@
+/**
+ * Prueffunktion des Zahlungsdienstes Polar (Auftrag A-15, 23.09.2026;
+ * Beobachtungen aus der Sandbox in Polar-Pruefung_2026-09-23.md, 3b).
+ *
+ * Gebaut wie lemonsqueezy-verifier.ts und **neben** dieser Klasse: drei
+ * Endpunkte des Kundenportals – activate, validate, deactivate –, alle ohne
+ * Anmeldung und damit ohne Geheimnis im Connector, Rumpf JSON, kein
+ * Authorization-Header. Kein SDK, keine neue Laufzeitabhaengigkeit; der
+ * Aufruf geht ueber fetch aus Node ab Version 20, Zeitueberschreitung 10 s.
+ *
+ * Unterschiede zu lemonsqueezy, die den Bau bestimmen:
+ * - Kennungen sind UUIDs (organization_id, benefit_id) statt Zahlen.
+ * - Zustaende heissen granted / revoked / disabled.
+ * - Die Aktivierung kommt bei activate als `id` (nicht `instance.id`);
+ *   validate traegt die Felder des Schluessels unmittelbar im Rumpf und die
+ *   Aktivierung in `activation`.
+ * - Gesperrt oder gekuendigt kommt als HTTP 404 mit eigenem Wortlaut, nicht
+ *   als Zustand; deactivate antwortet mit HTTP 204 ohne Rumpf.
+ * - Ohne Anmeldung gelten 3 Aufrufe je Sekunde; HTTP 429 zaehlt als
+ *   "nicht erreichbar", und zwischen zwei eigenen Aufrufen liegt eine Pause.
+ *
+ * Aufrufmuster (A-15 Nr. 4): ohne gespeicherte Aktivierung aktivieren, sonst
+ * mit activation_id pruefen. Kommt 404 "Not found" (die Aktivierung wurde
+ * beim Haendler oder vom Kunden im Portal entfernt), genau einmal neu
+ * aktivieren; scheitert das, bleibt es beim Ergebnis dieses Versuchs.
+ *
+ * Die Antworten enthalten Kundendaten (`customer`, `user`). Sie werden
+ * weder uebernommen noch protokolliert (A-8); nach aussen gehen nur
+ * Zustand, Ablauf und die Aktivierungskennung. Der Lizenzschluessel
+ * erscheint in keiner Meldung.
+ */
+import { describePolarIds, polarIdsConfigured, } from './polar-ids.js';
+import { SUPPORT_EMAIL } from '../product-info.js';
+export const DEFAULT_BASE_URL = 'https://api.polar.sh';
+/** Sandbox; nur in der Bauphase, ueber die Umgebungsvariable unten. */
+export const SANDBOX_BASE_URL = 'https://sandbox-api.polar.sh';
+export const POLAR_SANDBOX_ENV = 'LAYOUTBRIDGE_SPM_LICENSE_POLAR_SANDBOX';
+export const DEFAULT_TIMEOUT_MS = 10_000;
+/** Abstand vor einem zweiten eigenen Aufruf (Grenze des Dienstes: 3/s). */
+export const DEFAULT_RETRY_DELAY_MS = 1_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;
+}
+/** Einen Satz sauber abschliessen, damit zwei Saetze nicht zusammenlaufen. */
+function sentence(value) {
+    const trimmed = value.trimEnd();
+    return /[.!?]$/.test(trimmed) ? trimmed : trimmed + '.';
+}
+/** 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>');
+}
+/** Basisadresse fuer diesen Lauf: live, in der Bauphase auf Wunsch Sandbox. */
+export function resolvePolarBaseUrl(env = process.env) {
+    return env[POLAR_SANDBOX_ENV] === '1' ? SANDBOX_BASE_URL : DEFAULT_BASE_URL;
+}
+export class PolarVerifier {
+    name = 'polar';
+    ids;
+    baseUrl;
+    timeoutMs;
+    fetchImpl;
+    now;
+    retryDelayMs;
+    constructor(options) {
+        this.ids = options.ids;
+        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());
+        this.retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    }
+    /** Eine Zeile fuer die Startmeldung des Servers. */
+    describe() {
+        return `${this.name} (${this.baseUrl}, ids: ${describePolarIds(this.ids)})`;
+    }
+    async verify(key, context) {
+        if (context.instance_id === null) {
+            return this.interpret(await this.activate(key, context.instance_name), key);
+        }
+        const validated = await this.call('validate', { key, activation_id: context.instance_id });
+        const outcome = this.interpret(validated, key, context.instance_id);
+        if (outcome.status !== 'invalid' || !this.activationLikelyGone(validated))
+            return outcome;
+        /* Aktivierung entfernt: genau ein Aktivierungsversuch, mit Abstand. */
+        await this.pause();
+        return this.interpret(await this.activate(key, context.instance_name), key);
+    }
+    async deactivate(key, instanceId) {
+        const answer = await this.call('deactivate', { key, activation_id: instanceId });
+        if (answer.httpStatus === 204)
+            return;
+        if (answer.body === null) {
+            throw new Error('The licence service could not be reached: ' + answer.reason);
+        }
+        const reason = text(answer.body['detail']) ??
+            text(answer.body['error']) ??
+            'the service refused the deactivation (HTTP ' + String(answer.httpStatus) + ')';
+        throw new Error(redactKey(reason, key));
+    }
+    activate(key, label) {
+        return this.call('activate', { key, label });
+    }
+    /**
+     * Der Schluessel selbst ist noch brauchbar, nur die Aktivierung nicht
+     * mehr: HTTP 404 mit dem Wortlaut "Not found" (Sandbox 23.09.2026). Der
+     * eigene Wortlaut fuer einen erloschenen Schluessel ("no longer active")
+     * gehoert nicht dazu – dort waere ein zweiter Aufruf sinnlos.
+     */
+    activationLikelyGone(answer) {
+        if (answer.httpStatus !== 404 || answer.body === null)
+            return false;
+        if (this.keyGone(answer.body))
+            return false;
+        return true;
+    }
+    /** 404 mit dem Hinweis, dass der Schluessel selbst erloschen ist. */
+    keyGone(body) {
+        const detail = text(body['detail']);
+        return detail !== null && /no longer active/i.test(detail);
+    }
+    pause() {
+        if (this.retryDelayMs <= 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            setTimeout(resolve, this.retryDelayMs);
+        });
+    }
+    async call(endpoint, fields) {
+        /* organization_id gehoert in jeden Aufruf, sobald sie hinterlegt ist. */
+        const payload = { ...fields };
+        if (this.ids.organization_id !== null)
+            payload['organization_id'] = this.ids.organization_id;
+        let response;
+        try {
+            response = await this.fetchImpl(`${this.baseUrl}/v1/customer-portal/license-keys/${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (error) {
+            return { body: null, httpStatus: null, endpoint, reason: 'request failed (' + String(error) + ')' };
+        }
+        const httpStatus = response.status;
+        /* Erfolg ohne Rumpf: deactivate antwortet mit 204. */
+        if (httpStatus === 204) {
+            return { body: {}, httpStatus, endpoint, reason: '' };
+        }
+        if (httpStatus >= 500 || httpStatus === 429) {
+            return { body: null, httpStatus, endpoint, reason: 'the service answered HTTP ' + httpStatus };
+        }
+        let parsed;
+        try {
+            parsed = await response.json();
+        }
+        catch {
+            return { body: null, httpStatus, endpoint, reason: 'the answer was not readable JSON (HTTP ' + httpStatus + ')' };
+        }
+        const asRecord = record(parsed);
+        if (asRecord === null) {
+            return { body: null, httpStatus, endpoint, reason: 'the answer was not a JSON object (HTTP ' + httpStatus + ')' };
+        }
+        return { body: asRecord, httpStatus, endpoint, reason: '' };
+    }
+    /** Antwort des Dienstes auf die Ergebnisse aus S11 abbilden (A-15 Nr. 4). */
+    interpret(answer, key, storedActivationId = null) {
+        if (answer.body === null) {
+            return { status: 'unreachable', message: 'The licence service could not be reached: ' + answer.reason };
+        }
+        const body = answer.body;
+        /* activate antwortet mit einem license_key-Block, validate mit den
+           Feldern des Schluessels unmittelbar im Rumpf. */
+        const licenseKey = record(body['license_key']) ?? body;
+        const detail = text(body['detail']);
+        const expiresAt = text(licenseKey['expires_at']);
+        const activationId = this.activationId(answer, storedActivationId);
+        /* 1. Produkt vor allem anderen – auch wenn der Dienst "gueltig" sagt. */
+        const mismatch = this.productMismatch(licenseKey);
+        if (mismatch !== null) {
+            return this.outcome('product_mismatch', mismatch, key, expiresAt, activationId);
+        }
+        /* 2. Abgelaufen, gesperrt oder erloschen. */
+        const status = text(licenseKey['status']);
+        if (status === 'revoked' || this.expiryPassed(expiresAt) || this.keyGone(body)) {
+            const reason = detail ?? 'The licence has expired.';
+            return this.outcome('expired', reason, key, expiresAt, activationId);
+        }
+        /* 3. Erfolg. */
+        if (answer.httpStatus === 200 && status === 'granted') {
+            return this.outcome('valid', 'The licence key is valid.', key, expiresAt, activationId);
+        }
+        /* 4. Alles Uebrige. */
+        let reason = detail ?? text(body['error']) ?? 'The service did not confirm the licence key (HTTP ' + String(answer.httpStatus) + ').';
+        if (answer.httpStatus === 403 || /activation limit/i.test(reason)) {
+            /* Der Wortlaut des Dienstes endet ohne Punkt (Sandbox 23.09.2026). */
+            reason =
+                sentence(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 (answer.httpStatus === 200 && status !== null && status !== 'granted') {
+            reason = 'The service confirmed the key but reports the state "' + status + '".';
+        }
+        return this.outcome('invalid', reason, key, expiresAt, activationId);
+    }
+    /**
+     * activate liefert die Aktivierung als `id` im Rumpf, validate als
+     * `activation.id`; sonst bleibt die gespeicherte Kennung stehen.
+     */
+    activationId(answer, storedActivationId) {
+        const body = answer.body;
+        if (body === null)
+            return storedActivationId;
+        if (answer.endpoint === 'activate')
+            return text(body['id']) ?? storedActivationId;
+        const activation = record(body['activation']);
+        const fromActivation = activation === null ? null : text(activation['id']);
+        return fromActivation ?? storedActivationId;
+    }
+    outcome(status, message, key, expiresAt, activationId) {
+        return {
+            status,
+            message: redactKey(message, key),
+            expires_at: expiresAt,
+            instance_id: activationId,
+        };
+    }
+    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. Verglichen wird
+     * nur, was hinterlegt ist und was die Antwort auch nennt.
+     */
+    productMismatch(licenseKey) {
+        if (!polarIdsConfigured(this.ids))
+            return null;
+        const organizationId = text(licenseKey['organization_id']);
+        const benefitId = text(licenseKey['benefit_id']);
+        if (this.ids.organization_id !== null && organizationId !== null && organizationId.toLowerCase() !== this.ids.organization_id) {
+            return 'The licence key belongs to another organisation.';
+        }
+        if (this.ids.benefit_id !== null && benefitId !== null && benefitId.toLowerCase() !== this.ids.benefit_id) {
+            return 'The licence key belongs to another product.';
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=polar-verifier.js.map

package/dist/src/mcp/license/product-ids.js

@@ -0,0 +1,72 @@
+/**
+ * Hinterlegte Produktkennungen des Zahlungsdienstes (A-6 Ergaenzung
+ * 06.09.2026, Nr. 4).
+ *
+ * Der Dienst kennt keine Versionsangabe. Es gibt genau ein Produkt mit den
+ * Varianten Monatsabo und Jahresabo; der Connector haelt store_id,
+ * product_id und die zulaessigen variant_id-Werte fest und vergleicht sie
+ * mit dem meta-Block der Antwort. product_version aus dem Kontext wird
+ * nicht gegen die Antwort geprueft, weil der Dienst dazu nichts liefert.
+ *
+ * Solange kein Store besteht, sind die Konstanten leer (null bzw. leere
+ * Liste). Fuer die Live-Probe lassen sie sich von aussen setzen – ueber
+ * Umgebungsvariablen und ausschliesslich in der Bauphase, nie ueber
+ * config.json: config.json ist Kundenkonfiguration und koennte damit den
+ * Produktabgleich aushebeln.
+ */
+/** Kennungen des Live-Stores. Traegt das Vermarktungsprojekt nach. */
+export const PRODUCT_IDS = {
+    store_id: null,
+    product_id: null,
+    variant_ids: [],
+};
+function numberFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return null;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function numberListFromEnv(value) {
+    if (value === undefined)
+        return null;
+    const parts = value
+        .split(',')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (parts.length === 0)
+        return null;
+    const numbers = [];
+    for (const part of parts) {
+        const parsed = Number(part);
+        if (!Number.isFinite(parsed))
+            return null;
+        numbers.push(parsed);
+    }
+    return numbers;
+}
+/**
+ * Kennungen fuer diesen Lauf: die hinterlegten Konstanten, einzeln
+ * ueberschreibbar durch Umgebungsvariablen der Bauphase.
+ */
+export function resolveProductIds(env = process.env, base = PRODUCT_IDS) {
+    return {
+        store_id: numberFromEnv(env['LAYOUTBRIDGE_SPM_LICENSE_STORE_ID']) ?? base.store_id,
+        product_id: numberFromEnv(env['LAYOUTBRIDGE_SPM_LICENSE_PRODUCT_ID']) ?? base.product_id,
+        variant_ids: numberListFromEnv(env['LAYOUTBRIDGE_SPM_LICENSE_VARIANT_IDS']) ?? base.variant_ids,
+    };
+}
+/** Ist ueberhaupt eine Kennung hinterlegt? */
+export function productIdsConfigured(ids) {
+    return ids.store_id !== null || ids.product_id !== null || ids.variant_ids.length > 0;
+}
+/** Kurzfassung fuer Startzeile und Protokoll. */
+export function describeProductIds(ids) {
+    if (!productIdsConfigured(ids))
+        return 'not set';
+    const variants = ids.variant_ids.length > 0 ? ids.variant_ids.join('/') : '-';
+    return `store ${ids.store_id ?? '-'}, product ${ids.product_id ?? '-'}, variant ${variants}`;
+}
+//# sourceMappingURL=product-ids.js.map