layoutbridge-spm 0.0.1 → 1.0.0

package/dist/src/mcp/config.js

@@ -0,0 +1,125 @@
+/**
+ * Serverkonfiguration (E-54): Hauswerte, die nicht in die Werkzeug-
+ * beschreibungen gehoeren – Toleranzen, Preset-Namen, Schwellen. Eine
+ * JSON-Datei, einmal beim Start gelesen. Ein Parameter im Aufruf geht
+ * immer vor einem konfigurierten Wert.
+ *
+ * Ort der Datei: Umgebungsvariable LAYOUTBRIDGE_SPM_CONFIG (voller Pfad),
+ * sonst macOS ~/Library/Application Support/layoutbridge-spm/config.json,
+ * sonst ~/.layoutbridge-spm/config.json. Fehlt die Datei, gilt keine
+ * Konfiguration – der Server laeuft mit den neutralen Vorgaben.
+ */
+import { readFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+const KNOWN_KEYS = ['tracking_warn_beyond', 'min_ppi', 'export_pdf'];
+const KNOWN_PDF_KEYS = ['preset', 'fallback_preset', 'fallback_over_bytes'];
+export function defaultConfigPath(env = process.env, os = platform(), home = homedir()) {
+    const fromEnv = env['LAYOUTBRIDGE_SPM_CONFIG'];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    if (os === 'darwin') {
+        return join(home, 'Library', 'Application Support', 'layoutbridge-spm', 'config.json');
+    }
+    return join(home, '.layoutbridge-spm', 'config.json');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function takeNumber(source, key, min, problems, prefix) {
+    const value = source[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < min) {
+        problems.push(`${prefix}${key}: expected a number of ${min} or more, got ${JSON.stringify(value)}`);
+        return undefined;
+    }
+    return value;
+}
+function takeString(source, key, problems, prefix) {
+    const value = source[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string') {
+        problems.push(`${prefix}${key}: expected a string, got ${JSON.stringify(value)}`);
+        return undefined;
+    }
+    return value;
+}
+/** Text einer Konfigurationsdatei pruefen. Unbekannte Schluessel werden gemeldet und ignoriert. */
+export function parseServerConfig(text) {
+    const problems = [];
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (error) {
+        return { config: {}, problems: ['not valid JSON: ' + String(error)] };
+    }
+    if (!isRecord(raw)) {
+        return { config: {}, problems: ['the top level must be a JSON object'] };
+    }
+    const config = {};
+    for (const key of Object.keys(raw)) {
+        if (!KNOWN_KEYS.includes(key))
+            problems.push(`unknown key "${key}" ignored`);
+    }
+    const tracking = takeNumber(raw, 'tracking_warn_beyond', 0, problems, '');
+    if (tracking !== undefined)
+        config.tracking_warn_beyond = tracking;
+    const minPpi = takeNumber(raw, 'min_ppi', 1, problems, '');
+    if (minPpi !== undefined)
+        config.min_ppi = minPpi;
+    if (raw['export_pdf'] !== undefined) {
+        const pdf = raw['export_pdf'];
+        if (!isRecord(pdf)) {
+            problems.push('export_pdf: expected an object');
+        }
+        else {
+            for (const key of Object.keys(pdf)) {
+                if (!KNOWN_PDF_KEYS.includes(key))
+                    problems.push(`unknown key "export_pdf.${key}" ignored`);
+            }
+            const out = {};
+            const preset = takeString(pdf, 'preset', problems, 'export_pdf.');
+            if (preset !== undefined)
+                out.preset = preset;
+            const fallback = takeString(pdf, 'fallback_preset', problems, 'export_pdf.');
+            if (fallback !== undefined)
+                out.fallback_preset = fallback;
+            const bytes = takeNumber(pdf, 'fallback_over_bytes', 0, problems, 'export_pdf.');
+            if (bytes !== undefined)
+                out.fallback_over_bytes = bytes;
+            config.export_pdf = out;
+        }
+    }
+    return { config, problems };
+}
+/** Konfigurationsdatei lesen. Keine Datei = leere Konfiguration, kein Fehler. */
+export function loadServerConfig(path = defaultConfigPath()) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT')
+            return { config: {}, path: null, problems: [] };
+        return { config: {}, path, problems: ['could not read ' + path + ': ' + String(error)] };
+    }
+    const parsed = parseServerConfig(text);
+    return { config: parsed.config, path, problems: parsed.problems };
+}
+/**
+ * Konfigurierte Vorgaben in die Befehlsargumente legen – nur dort, wo der
+ * Aufruf selbst nichts gesagt hat. Felder ohne Wert werden nicht gesetzt.
+ */
+export function applyConfigDefaults(args, defaults) {
+    const out = { ...args };
+    for (const key of Object.keys(defaults)) {
+        if (out[key] === undefined && defaults[key] !== undefined)
+            out[key] = defaults[key];
+    }
+    return out;
+}
+//# sourceMappingURL=config.js.map

package/dist/src/mcp/dispatch.js

@@ -0,0 +1,123 @@
+/**
+ * Bindeglied: geprueften Parametersatz in einen Befehl uebersetzen, ueber den
+ * Transport schicken, protokollieren, Ergebnisumschlag zurueckgeben.
+ * Kennt InDesign nicht, kennt den Transport nur als Schnittstelle.
+ */
+import { homedir } from 'node:os';
+import { z } from 'zod';
+import { applyConfigDefaults } from './config.js';
+import { maskHome } from './logging.js';
+import { transportError, } from '../transport/transport.js';
+/** Entfernt Felder ohne Wert, damit der Befehl keine leeren Schluessel traegt. */
+export function dropUndefined(input) {
+    const out = {};
+    for (const key of Object.keys(input)) {
+        if (input[key] !== undefined)
+            out[key] = input[key];
+    }
+    return out;
+}
+/** Parameter pruefen und daraus den Befehl bauen – ohne InDesign. */
+export function buildCommand(definition, rawInput, config = {}) {
+    /*
+     * strictObject: unbekannte Parameter sind ein Fehler, kein stilles Weglassen.
+     * Sonst wuerde z. B. add_page mit "position" statt "at" die Seite still ans
+     * Ende haengen (Spezifikation nennt die verwechselbaren Namen ausdruecklich).
+     */
+    const schema = z.strictObject(definition.inputShape);
+    const parsed = schema.safeParse(rawInput ?? {});
+    if (!parsed.success) {
+        const issues = parsed.error.issues.map((issue) => (issue.path.length > 0 ? issue.path.join('.') + ': ' : '') + issue.message);
+        return {
+            error: transportError('invalid_argument', issues.join('; '), { tool: definition.name, issues }),
+        };
+    }
+    const values = dropUndefined(parsed.data);
+    let args = definition.buildArgs ? definition.buildArgs(values) : values;
+    /* Konfigurierte Vorgaben erst nach der Pruefung: der Aufruf geht vor (E-54). */
+    if (definition.configArgs)
+        args = applyConfigDefaults(args, definition.configArgs(config));
+    return { command: { cmd: definition.command, args: dropUndefined(args) } };
+}
+/**
+ * Ersetzt das Benutzerverzeichnis in der Fehlerantwort durch "~" – in
+ * `error.message` und in `error.details` (Auftrag A-8, Punkt 4; Entscheidung
+ * des Vermarktungsprojekts vom 14.09.2026, Vermerk E-68). Der Pfad bleibt
+ * lesbar, allein der Benutzername faellt weg. Aufbau und Felder der
+ * Fehlerantwort bleiben unveraendert (A-5).
+ */
+export function maskErrorPaths(result, home = homedir()) {
+    if (result.error === undefined)
+        return result;
+    return {
+        ...result,
+        error: {
+            kind: result.error.kind,
+            message: maskHome(result.error.message, home),
+            details: maskDeep(result.error.details, home, 0),
+        },
+    };
+}
+/** Wie maskErrorPaths, aber fuer beliebig verschachtelte Details. */
+function maskDeep(value, home, depth) {
+    if (typeof value === 'string')
+        return maskHome(value, home);
+    if (depth >= 6)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => maskDeep(item, home, depth + 1));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const key of Object.keys(value)) {
+            out[key] = maskDeep(value[key], home, depth + 1);
+        }
+        return out;
+    }
+    return value;
+}
+/** Ein Werkzeugaufruf von Anfang bis Ende. */
+export async function runTool(definition, rawInput, transport, logger, options = {}) {
+    const built = buildCommand(definition, rawInput, options.config ?? {});
+    if ('error' in built) {
+        const masked = maskErrorPaths(built.error);
+        logger.log({
+            tool: definition.name,
+            command: definition.command,
+            args: {},
+            duration_ms: 0,
+            ok: false,
+            error_kind: masked.error?.kind ?? 'invalid_argument',
+            error_message: masked.error?.message ?? '',
+            warnings: [],
+            result_keys: [],
+        });
+        return masked;
+    }
+    const startedAt = Date.now();
+    let result;
+    try {
+        const sendOptions = options.timeoutMs === undefined ? undefined : { timeoutMs: options.timeoutMs };
+        result = await transport.send(built.command, sendOptions);
+    }
+    catch (error) {
+        result = transportError('script_error', 'Transport failed: ' + String(error), null);
+    }
+    const duration = Date.now() - startedAt;
+    result = maskErrorPaths(result);
+    if (result.ok && definition.mapResult) {
+        result = { ...result, ...definition.mapResult(result) };
+    }
+    logger.log({
+        tool: definition.name,
+        command: built.command.cmd,
+        args: built.command.args,
+        duration_ms: duration,
+        ok: result.ok === true,
+        error_kind: result.error?.kind ?? null,
+        error_message: result.error?.message ?? null,
+        warnings: Array.isArray(result.warnings) ? result.warnings : [],
+        result_keys: Object.keys(result).filter((key) => key !== 'ok' && key !== 'warnings'),
+    });
+    return result;
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/src/mcp/license/free-tools.js

@@ -0,0 +1,16 @@
+/**
+ * Freemium-Schalter (A-6 Nr. 4, E-60). Vorgabe: alles gesperrt.
+ *
+ * Absichtlich Konstanten im Code und kein Konfigurationsschluessel – was in
+ * config.json steht, koennte jeder Kunde aendern. Freigabe einzelner
+ * Werkzeuge: Namen in FREE_TOOLS eintragen; alle lesend gemeldeten Werkzeuge
+ * (readOnly) auf einmal: FREE_READ_ONLY_TOOLS auf true.
+ */
+export const FREE_READ_ONLY_TOOLS = false;
+export const FREE_TOOLS = new Set([]);
+export function isFreeTool(name, readOnly) {
+    if (FREE_TOOLS.has(name))
+        return true;
+    return FREE_READ_ONLY_TOOLS && readOnly;
+}
+//# sourceMappingURL=free-tools.js.map

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

@@ -0,0 +1,209 @@
+/**
+ * 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';
+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 LAYOUTBRIDGE_SPM_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,96 @@
+/**
+ * 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';
+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 Sascha, 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';
+export function resolveLicenseProvider(env = process.env) {
+    const value = env[LICENSE_PROVIDER_ENV];
+    return value === 'polar' || value === 'lemonsqueezy' ? value : DEFAULT_LICENSE_PROVIDER;
+}
+export function createVerifier(env = process.env) {
+    if (resolveLicenseProvider(env) === 'polar') {
+        return new PolarVerifier({ ids: resolvePolarIds(env), baseUrl: resolvePolarBaseUrl(env) });
+    }
+    return new LemonSqueezyVerifier({ productIds: resolveProductIds(env) });
+}
+/** Datenschutzerklaerung des gewaehlten Zahlungsdienstes (A-15 Nr. 5). */
+export function paymentPrivacyPolicyUrl(env = process.env) {
+    return paymentPrivacyPolicyUrlFor(resolveLicenseProvider(env));
+}
+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 LAYOUTBRIDGE_SPM_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,56 @@
+/**
+ * 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';
+/** Form der erzeugten Kennung. */
+export const INSTANCE_NAME_PATTERN = /^layoutbridge-[0-9a-f]{8}$/;
+export function defaultInstanceNamePath(os = platform(), home = homedir()) {
+    return licensePathApi(os).join(defaultLicenseDirectory(os, home), '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()) {
+    const fromEnv = env['LAYOUTBRIDGE_SPM_INSTANCE_NAME'];
+    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(`[layoutbridge-spm] cannot store the instance name: ${String(error)}\n`);
+    }
+    return created;
+}
+//# sourceMappingURL=instance-name.js.map