layoutbridge-spm 0.0.1 → 1.0.0

package/dist/src/mcp/license/state-store.js

@@ -0,0 +1,91 @@
+/**
+ * Speicher fuer das letzte Pruefergebnis (E-60): eine kleine JSON-Datei
+ * neben der Serverkonfiguration. Fehlt sie oder ist sie unlesbar, gilt
+ * "kein Ergebnis" – nie ein Absturz.
+ */
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const STATUSES = ['valid', 'invalid', 'expired', 'product_mismatch', 'unreachable'];
+function optionalString(value) {
+    return typeof value === 'string' ? value : null;
+}
+/** Text der Speicherdatei pruefen; alles Unbrauchbare ergibt null. */
+export function parseLicenseState(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return null;
+    const record = raw;
+    const fp = record['key_fingerprint'];
+    const status = record['status'];
+    const checkedAt = record['checked_at'];
+    if (typeof fp !== 'string' || fp.length === 0)
+        return null;
+    if (typeof status !== 'string' || !STATUSES.includes(status))
+        return null;
+    if (typeof checkedAt !== 'string' || Number.isNaN(Date.parse(checkedAt)))
+        return null;
+    return {
+        key_fingerprint: fp,
+        status: status,
+        checked_at: checkedAt,
+        last_valid_at: optionalString(record['last_valid_at']),
+        expires_at: optionalString(record['expires_at']),
+        instance_id: optionalString(record['instance_id']),
+        /*
+         * A-8 (13.09.2026, E-64): das fruehere Feld customer trug die
+         * E-Mail-Adresse des Kunden. Es wird nicht mehr gelesen und beim
+         * naechsten Schreiben ueberschrieben – so verschwindet es von selbst.
+         */
+        verifier: typeof record['verifier'] === 'string' ? record['verifier'] : '',
+        message: typeof record['message'] === 'string' ? record['message'] : '',
+    };
+}
+export class FileLicenseStateStore {
+    location;
+    constructor(location) {
+        this.location = location;
+    }
+    load() {
+        let text;
+        try {
+            text = readFileSync(this.location, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        return parseLicenseState(text);
+    }
+    save(state) {
+        mkdirSync(dirname(this.location), { recursive: true });
+        writeFileSync(this.location, JSON.stringify(state, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+    }
+    clear() {
+        try {
+            unlinkSync(this.location);
+        }
+        catch {
+            /* schon weg */
+        }
+    }
+}
+/** Speicher im Arbeitsspeicher – fuer Tests. */
+export class MemoryLicenseStateStore {
+    location = 'memory';
+    state = null;
+    load() {
+        return this.state === null ? null : { ...this.state };
+    }
+    save(state) {
+        this.state = { ...state };
+    }
+    clear() {
+        this.state = null;
+    }
+}
+//# sourceMappingURL=state-store.js.map

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

@@ -0,0 +1,11 @@
+/**
+ * Lizenzschranke (Auftrag A-6 mit Nachtrag 05.09.2026, E-60): Typen.
+ *
+ * Diese Schicht kennt weder InDesign noch den Transport. Sie kennt nur den
+ * Schluessel, ein gespeichertes Pruefergebnis und eine austauschbare
+ * Prueffunktion (LicenseVerifier). Der eigentliche Aufruf beim
+ * Zahlungsdienst kommt als eigene Klasse an diese Schnittstelle, sobald der
+ * Dienst mit Endpunkten beauftragt ist.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/mcp/logging.js

@@ -0,0 +1,270 @@
+/**
+ * Protokoll: eine Zeile je Aufruf (Spezifikation, allgemeine Anforderung 11).
+ * Jede Instanz schreibt in eine eigene Datei, damit sich mehrere Server nicht
+ * gegenseitig ins Protokoll schreiben.
+ *
+ * Wichtig: nie auf die Standardausgabe schreiben – dort laeuft das
+ * MCP-Protokoll. Nur in die Datei und notfalls auf die Standardfehlerausgabe.
+ *
+ * Datensparsamkeit (Auftrag A-8 des Vermarktungsprojekts, 13.09.2026,
+ * Vermerk E-64): Der Aufrufsatz `args` wird nicht mehr roh geschrieben.
+ * Festgehalten werden die Parameternamen; Werte nur dort, wo sie fuer die
+ * Fehlersuche noetig und harmlos sind – Zahlen, Wahrheitswerte, Kennungen,
+ * Indizes, Aufzaehlungswerte. Zeichenketten, die Dokumentinhalt sein
+ * koennen, werden durch eine Laengenangabe ersetzt. Pfade behalten ihre
+ * Form, das Benutzerverzeichnis wird durch "~" ersetzt. Wie tief
+ * protokolliert wird, steuert LAYOUTBRIDGE_SPM_LOG_LEVEL.
+ */
+import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { LICENSE_TERMS_URL, SUPPORT_EMAIL } from './product-info.js';
+export const DEFAULT_LOG_LEVEL = 'basic';
+export const DEFAULT_LOG_KEEP_DAYS = 30;
+/** Laengste Zeichenkette, die auch ausserhalb der Inhaltsfelder im Klartext bleibt. */
+const MAX_PLAIN_STRING = 60;
+/** Laengster Pfad, der im Klartext bleibt. */
+const MAX_PATH_STRING = 300;
+/** Hoechstzahl protokollierter Eintraege je Liste oder Objekt. */
+const MAX_ITEMS = 20;
+/**
+ * Parameter, deren Wert Dokumentinhalt sein kann. Ihr Wert wird immer
+ * ersetzt – bei Zeichenketten durch die Laengenangabe, bei Listen und
+ * Objekten durch die Zahl der Eintraege. Zahlen und Wahrheitswerte bleiben
+ * (z. B. `rows` als Zeilenzahl in create_table).
+ */
+const CONTENT_KEYS = [
+    'cells',
+    'content',
+    'find',
+    'initial_text',
+    'marker',
+    'replace',
+    'rows',
+    'style_map',
+    'template',
+    'text',
+    'text_after',
+    'text_before',
+    'values',
+];
+function isContentKey(key) {
+    if (CONTENT_KEYS.includes(key))
+        return true;
+    return key.endsWith('_text') || key.endsWith('_texts');
+}
+/** Zeichen zaehlen, nicht Bytes. */
+export function charCount(value) {
+    return Array.from(value).length;
+}
+function textNote(value) {
+    return '<Text, ' + String(charCount(value)) + ' Zeichen>';
+}
+/** Benutzerverzeichnis in einem Text durch "~" ersetzen. */
+export function maskHome(value, home = homedir()) {
+    if (home.length < 2)
+        return value;
+    return value.split(home).join('~');
+}
+function looksLikePath(value) {
+    return value.includes('/') || value.includes('\\') || /^[A-Za-z]:/.test(value);
+}
+function filterValue(key, value, home, depth) {
+    if (value === null)
+        return null;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (isContentKey(key)) {
+        if (typeof value === 'string')
+            return textNote(value);
+        if (Array.isArray(value))
+            return '<Liste, ' + String(value.length) + ' Eintraege>';
+        if (typeof value === 'object')
+            return '<Objekt, ' + String(Object.keys(value).length) + ' Felder>';
+        return '<Wert>';
+    }
+    if (typeof value === 'string') {
+        const masked = maskHome(value, home);
+        if (value.includes('\n'))
+            return textNote(value);
+        /*
+         * Pfade bleiben lesbar – ohne sie ist ein Ablagefehler nicht zu finden.
+         * Der Benutzername ist heraus, und eine Zeile ohne Umbruch, die einen
+         * Trenner enthaelt, ist kein Fliesstext.
+         */
+        if (looksLikePath(value))
+            return charCount(value) > MAX_PATH_STRING ? textNote(value) : masked;
+        if (charCount(value) > MAX_PLAIN_STRING)
+            return textNote(value);
+        return masked;
+    }
+    if (depth >= 3)
+        return '<verschachtelt>';
+    if (Array.isArray(value)) {
+        const shown = value.slice(0, MAX_ITEMS).map((item) => filterValue(key, item, home, depth + 1));
+        if (value.length > MAX_ITEMS)
+            shown.push('<' + String(value.length - MAX_ITEMS) + ' weitere>');
+        return shown;
+    }
+    if (typeof value === 'object') {
+        const record = value;
+        const out = {};
+        let count = 0;
+        for (const innerKey of Object.keys(record)) {
+            if (count >= MAX_ITEMS) {
+                out['…'] = '<' + String(Object.keys(record).length - MAX_ITEMS) + ' weitere>';
+                break;
+            }
+            out[innerKey] = filterValue(innerKey, record[innerKey], home, depth + 1);
+            count += 1;
+        }
+        return out;
+    }
+    return '<Wert>';
+}
+/** Aufrufsatz fuer das Protokoll entschaerfen (Stufe "basic"). */
+export function filterArgs(args, home = homedir()) {
+    const out = {};
+    for (const key of Object.keys(args)) {
+        out[key] = filterValue(key, args[key], home, 0);
+    }
+    return out;
+}
+/** Protokollzeile fuer die Stufe "basic" aufbereiten. */
+export function filterEntry(entry, home = homedir()) {
+    return {
+        ...entry,
+        args: filterArgs(entry.args, home),
+        error_message: entry.error_message === null ? null : maskHome(entry.error_message, home),
+        warnings: entry.warnings.map((warning) => maskHome(warning, home)),
+    };
+}
+export function readLogLevel(env = process.env) {
+    const raw = env['LAYOUTBRIDGE_SPM_LOG_LEVEL'];
+    if (raw === undefined)
+        return DEFAULT_LOG_LEVEL;
+    const value = raw.trim().toLowerCase();
+    if (value === 'off' || value === 'basic' || value === 'full')
+        return value;
+    return DEFAULT_LOG_LEVEL;
+}
+/** Aufbewahrungsfrist in Tagen; 0 schaltet das Aufraeumen ab. */
+export function readLogKeepDays(env = process.env) {
+    const raw = env['LAYOUTBRIDGE_SPM_LOG_KEEP_DAYS'];
+    if (raw === undefined || raw.trim().length === 0)
+        return DEFAULT_LOG_KEEP_DAYS;
+    const value = Number(raw.trim());
+    if (!Number.isFinite(value) || value < 0)
+        return DEFAULT_LOG_KEEP_DAYS;
+    return Math.floor(value);
+}
+export function defaultLogDirectory() {
+    const fromEnv = process.env['LAYOUTBRIDGE_SPM_LOG_DIR'];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    if (platform() === 'darwin') {
+        return join(homedir(), 'Library', 'Logs', 'layoutbridge-spm');
+    }
+    return join(homedir(), '.layoutbridge-spm', 'logs');
+}
+function twoDigits(value) {
+    return String(value).padStart(2, '0');
+}
+/**
+ * Protokolldateien loeschen, die aelter als `keepDays` Tage sind. Das Datum
+ * kommt aus dem Dateinamen; gerechnet wird ab dem Ende des genannten Tages,
+ * damit nichts zu frueh verschwindet. Gibt die geloeschten Namen zurueck.
+ */
+export function removeOldLogs(directory, keepDays, now = new Date()) {
+    if (keepDays <= 0)
+        return [];
+    const cutoff = now.getTime() - keepDays * 24 * 60 * 60 * 1000;
+    let names;
+    try {
+        names = readdirSync(directory);
+    }
+    catch {
+        return [];
+    }
+    const removed = [];
+    for (const name of names) {
+        const match = /^(\d{4})-(\d{2})-(\d{2})_pid\d+\.log$/.exec(name);
+        if (match === null)
+            continue;
+        const endOfDay = Date.parse(match[1] + '-' + match[2] + '-' + match[3] + 'T23:59:59.999Z');
+        if (Number.isNaN(endOfDay) || endOfDay >= cutoff)
+            continue;
+        try {
+            unlinkSync(join(directory, name));
+            removed.push(name);
+        }
+        catch {
+            /* schon weg oder nicht loeschbar – kein Grund fuer einen Abbruch */
+        }
+    }
+    return removed;
+}
+export class CallLogger {
+    file;
+    level;
+    removedLogs;
+    home;
+    broken = false;
+    constructor(directory = defaultLogDirectory(), now = new Date(), options = {}) {
+        this.level = options.level ?? readLogLevel();
+        this.home = options.home ?? homedir();
+        const stamp = now.getFullYear() +
+            '-' + twoDigits(now.getMonth() + 1) +
+            '-' + twoDigits(now.getDate());
+        this.file = join(directory, `${stamp}_pid${process.pid}.log`);
+        this.removedLogs = removeOldLogs(directory, options.keepDays ?? readLogKeepDays(), now);
+        if (this.level === 'off') {
+            this.broken = true;
+            return;
+        }
+        try {
+            mkdirSync(directory, { recursive: true });
+        }
+        catch (error) {
+            this.broken = true;
+            process.stderr.write(`[layoutbridge-spm] no log directory: ${String(error)}\n`);
+            return;
+        }
+        this.writeLine({
+            ts: new Date().toISOString(),
+            event: 'start',
+            log_level: this.level,
+            note: this.level === 'full'
+                ? 'Log level "full": tool arguments are written unfiltered, including document text and paths with your user name. Set LAYOUTBRIDGE_SPM_LOG_LEVEL=basic when the support case is closed.'
+                : 'Log level "basic": argument names with harmless values only; text is reduced to its length, paths hide the user name.',
+            removed_old_logs: this.removedLogs.length,
+            /* Lizenzbedingungen und Support-Adresse in der Startzeile des Protokolls (A-11 Nr. 3, A-10 Nr. 1). */
+            license_terms: LICENSE_TERMS_URL,
+            support: SUPPORT_EMAIL,
+        });
+    }
+    log(entry) {
+        if (this.broken)
+            return;
+        const prepared = this.level === 'full' ? entry : filterEntry(entry, this.home);
+        this.writeLine({ ts: new Date().toISOString(), ...prepared });
+    }
+    writeLine(record) {
+        if (this.broken)
+            return;
+        try {
+            appendFileSync(this.file, JSON.stringify(record) + '\n', 'utf8');
+        }
+        catch (error) {
+            this.broken = true;
+            process.stderr.write(`[layoutbridge-spm] cannot write log: ${String(error)}\n`);
+        }
+    }
+}
+/** Protokollsenke, die nichts tut – fuer Tests. */
+export class NullLogger {
+    log() {
+        /* absichtlich leer */
+    }
+}
+//# sourceMappingURL=logging.js.map

package/dist/src/mcp/product-info.js

@@ -0,0 +1,48 @@
+/**
+ * Feste Produktangaben, die in Meldungen und Protokoll erscheinen (Auftraege
+ * A-10 Nr. 1 und A-11 Nr. 1/3 des Vermarktungsprojekts, 17.09.2026; E-72).
+ *
+ * Die Adressen sind vom Vermarktungsprojekt festgelegt und aendern sich
+ * nicht mehr; die englische Fassung ist massgeblich fuer Verzeichnisse, die
+ * deutsche fuer Kunden. Keine Hauswerte, keine Umgebungsnamen – nur das,
+ * was jeder Kunde des Produkts sehen soll.
+ */
+/** Support-Eingang (A-10 Nr. 1; seit A-12 Nr. 1 unter dem Dach MCP Interfaces, E-75). Erscheint im Klartext in jeder Meldung der Fehlerart `license`. */
+export const SUPPORT_EMAIL = 'kontakt@mcp-interfaces.com';
+/** Lizenzbedingungen (EULA), englisch (massgeblich fuer Verzeichnisse) und deutsch. */
+export const LICENSE_TERMS_URL = 'https://mcp-interfaces.com/layoutbridge/license.html';
+export const LICENSE_TERMS_URL_DE = 'https://mcp-schnittstellen.de/layoutbridge/lizenzbedingungen.html';
+/** Datenschutzerklaerung des Produkts, englisch und deutsch; dazu die des Zahlungsdienstes. */
+export const PRIVACY_POLICY_URL = 'https://mcp-interfaces.com/layoutbridge/privacy.html';
+export const PRIVACY_POLICY_URL_DE = 'https://mcp-schnittstellen.de/layoutbridge/datenschutz.html';
+/**
+ * Datenschutzerklaerung je Zahlungsdienst (A-15 Nr. 5, 23.09.2026). Zum
+ * Verkaufsstart gilt Polar (A-15a); lemonsqueezy bleibt als Rueckfall der
+ * Bauphase, ausgegeben wird der Eintrag des gewaehlten Dienstes.
+ */
+export const PAYMENT_PRIVACY_POLICY_URLS = {
+    lemonsqueezy: 'https://www.lemonsqueezy.com/privacy',
+    polar: 'https://polar.sh/legal/privacy',
+};
+/**
+ * Der Eintrag des vorgegebenen Dienstes (polar seit A-15a Nr. 2; muss zu
+ * DEFAULT_LICENSE_PROVIDER in license/index.ts passen, ein Test wacht
+ * darueber). Steht in manifest.json und in der README.
+ */
+export const PAYMENT_PRIVACY_POLICY_URL = PAYMENT_PRIVACY_POLICY_URLS['polar'];
+/** Datenschutzerklaerung eines bestimmten Dienstes; unbekannt = Vorgabe. */
+export function paymentPrivacyPolicyUrlFor(provider) {
+    return PAYMENT_PRIVACY_POLICY_URLS[provider] ?? PAYMENT_PRIVACY_POLICY_URL;
+}
+/** Produktseite. */
+export const PRODUCT_PAGE_URL = 'https://mcp-interfaces.com/layoutbridge/';
+export const PRODUCT_PAGE_URL_DE = 'https://mcp-schnittstellen.de/layoutbridge/';
+/** Haengt den Support-Hinweis an eine Meldung, sofern die Adresse nicht schon darin steht. */
+export function withSupportHint(message) {
+    if (message.includes(SUPPORT_EMAIL))
+        return message;
+    const trimmed = message.trimEnd();
+    const separator = /[.!?]$/.test(trimmed) ? ' ' : '. ';
+    return trimmed + separator + 'Support: ' + SUPPORT_EMAIL;
+}
+//# sourceMappingURL=product-info.js.map

package/dist/src/mcp/server.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+/**
+ * layoutbridge-spm – MCP-Server für Adobe InDesign (bis 04.09.2026: indesign-connector-spm).
+ *
+ * Startet den Server ueber die Standardein-/-ausgabe (stdio) und meldet die
+ * Werkzeuge aus tools.ts an. Aufrufe laufen sequenziell (SerialTransport).
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadServerConfig } from './config.js';
+import { CallLogger } from './logging.js';
+import { runTool } from './dispatch.js';
+import { createLicenseGate, runDeactivation } from './license/index.js';
+import { LICENSE_TERMS_URL, LICENSE_TERMS_URL_DE, SUPPORT_EMAIL } from './product-info.js';
+import { createTerminalIo, runSetup } from './setup.js';
+import { TOOLS } from './tools.js';
+import { nodeVersionProblem } from './start.cjs';
+import { ComTransport } from '../transport/com.js';
+import { OsascriptTransport } from '../transport/osascript.js';
+import { SerialTransport } from '../transport/queue.js';
+export const SERVER_NAME = 'layoutbridge-spm';
+/**
+ * Version aus package.json – eine Quelle fuer Paket, Server, server.json und
+ * manifest.json (A-11 Nr. 6; scripts/version-sync.mjs zieht die beiden
+ * Dateien nach). Faellt auf 0.0.0 zurueck, wenn package.json nicht lesbar ist.
+ */
+export const SERVER_VERSION = readPackageVersion();
+function readPackageVersion() {
+    try {
+        const packageJson = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+        const parsed = JSON.parse(readFileSync(packageJson, 'utf8'));
+        return typeof parsed.version === 'string' ? parsed.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * Haelt fest, ob noch ein Aufruf laeuft. Der Server darf sich erst beenden,
+ * wenn die Eingabe zu Ende ist UND keine Antwort mehr aussteht – sonst bricht
+ * er einen laufenden InDesign-Aufruf mitten im Satz ab.
+ */
+export class Lifecycle {
+    onIdle;
+    inFlight = 0;
+    inputEnded = false;
+    stopping = false;
+    constructor(onIdle) {
+        this.onIdle = onIdle;
+    }
+    begin() {
+        this.inFlight += 1;
+    }
+    end() {
+        this.inFlight = Math.max(0, this.inFlight - 1);
+        this.check();
+    }
+    inputIsOver() {
+        this.inputEnded = true;
+        this.check();
+    }
+    get busy() {
+        return this.inFlight > 0;
+    }
+    check() {
+        if (this.inputEnded && this.inFlight === 0 && !this.stopping) {
+            this.stopping = true;
+            this.onIdle();
+        }
+    }
+}
+export function createServer(transport, logger, lifecycle, config = {}, gate) {
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
+    for (const definition of TOOLS) {
+        server.registerTool(definition.name, {
+            title: definition.title,
+            description: definition.description,
+            inputSchema: definition.inputShape,
+            annotations: {
+                title: definition.title,
+                readOnlyHint: definition.readOnly,
+                destructiveHint: definition.destructive === true,
+                idempotentHint: definition.readOnly,
+                openWorldHint: false,
+            },
+        }, async (input) => {
+            lifecycle?.begin();
+            try {
+                /* Lizenzschranke (E-60): vor dem Transport, InDesign bleibt unberuehrt. */
+                let graceWarning = null;
+                if (gate !== undefined) {
+                    const decision = await gate.decide(definition.name, definition.readOnly);
+                    if (!decision.allowed) {
+                        const refused = gate.toError(decision);
+                        logger.log({
+                            tool: definition.name,
+                            command: definition.command,
+                            args: {},
+                            duration_ms: 0,
+                            ok: false,
+                            error_kind: 'license',
+                            error_message: refused.error?.message ?? '',
+                            warnings: [],
+                            result_keys: [],
+                        });
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(refused, null, 2) }],
+                            isError: true,
+                        };
+                    }
+                    graceWarning = decision.message;
+                }
+                let result = await runTool(definition, input, transport, logger, {
+                    timeoutMs: definition.timeoutMs,
+                    config,
+                });
+                if (graceWarning !== null) {
+                    const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+                    result = { ...result, warnings: [...warnings, graceWarning] };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                    isError: result.ok !== true,
+                };
+            }
+            finally {
+                lifecycle?.end();
+            }
+        });
+    }
+    return server;
+}
+/**
+ * Startet den Server ueber die Standardein-/-ausgabe und kuemmert sich um ein
+ * sauberes Ende: Ende der Eingabe merken, aber erst aufhoeren, wenn die letzte
+ * Antwort geschrieben ist.
+ */
+export async function startStdioServer(transport, logger, config = {}, gate) {
+    let stopping = false;
+    const stop = (code) => {
+        if (stopping)
+            return;
+        stopping = true;
+        void transport.close().finally(() => {
+            /* Erst schreiben lassen, dann gehen. */
+            process.stdout.write('', () => process.exit(code));
+        });
+    };
+    const lifecycle = new Lifecycle(() => stop(0));
+    const server = createServer(transport, logger, lifecycle, config, gate);
+    process.stdin.on('end', () => lifecycle.inputIsOver());
+    process.stdin.on('close', () => lifecycle.inputIsOver());
+    server.server.onclose = () => lifecycle.inputIsOver();
+    process.on('SIGINT', () => stop(0));
+    process.on('SIGTERM', () => stop(0));
+    await server.connect(new StdioServerTransport());
+    return server;
+}
+/**
+ * Rechnerwechsel (A-6 Ergaenzung Nr. 7): `layoutbridge-spm --deactivate`
+ * gibt die Aktivierung dieses Arbeitsplatzes beim Dienst frei. Laeuft ohne
+ * InDesign und ohne Client; kein Werkzeug im Katalog (A-5).
+ */
+async function deactivateFromCommandLine() {
+    const result = await runDeactivation();
+    process.stderr.write(`[${SERVER_NAME}] ${result.message}\n`);
+    process.exit(result.ok ? 0 : 1);
+}
+/**
+ * Einrichtung (A-13 Nr. 1, E-76): `layoutbridge-spm --setup` traegt den
+ * Server in Claude Desktop ein und legt den Lizenzschluessel ab. Nur auf
+ * ausdrueckliche Eingabe, kein Werkzeug im Katalog (A-5); laeuft vor
+ * Protokoll, Transport und Lizenzschranke, also ohne Netz und ohne InDesign.
+ */
+async function setupFromCommandLine() {
+    const code = await runSetup(process.argv.slice(2), createTerminalIo(), {
+        platform: process.platform,
+        home: homedir(),
+        env: process.env,
+        now: new Date(),
+        nodeVersion: process.version,
+    });
+    process.exit(code);
+}
+/**
+ * Transport nach Plattform. Die einzige Stelle im Server, die zwischen den
+ * Wegen unterscheidet; alles darueber kennt nur die Schnittstelle.
+ * Der Windows-Weg ist gebaut, aber noch nicht an einem laufenden InDesign
+ * nachgewiesen (Vermerk E-67).
+ */
+function createPlatformTransport() {
+    return process.platform === 'win32' ? new ComTransport() : new OsascriptTransport();
+}
+/** Eine Zeile mit Lizenzbedingungen und Support-Adresse fuer Startmeldung und Protokoll. */
+export function describeProductTerms() {
+    return `licence terms: ${LICENSE_TERMS_URL} (de: ${LICENSE_TERMS_URL_DE}), support: ${SUPPORT_EMAIL}`;
+}
+async function main() {
+    if (process.argv.includes('--setup')) {
+        await setupFromCommandLine();
+        return;
+    }
+    if (process.argv.includes('--deactivate')) {
+        await deactivateFromCommandLine();
+        return;
+    }
+    const logger = new CallLogger();
+    const transport = new SerialTransport(createPlatformTransport());
+    const loaded = loadServerConfig();
+    const gate = createLicenseGate({ product: SERVER_NAME, version: SERVER_VERSION });
+    process.stderr.write(`[${SERVER_NAME}] ${SERVER_VERSION} started, ${TOOLS.length} tools, transport: ${transport.name}, log: ${logger.file} (level ${logger.level}${logger.removedLogs.length > 0 ? `, ${logger.removedLogs.length} old log file(s) removed` : ''}), config: ${loaded.path ?? 'none'}\n`);
+    if (logger.level === 'full') {
+        process.stderr.write(`[${SERVER_NAME}] log level "full": tool arguments are written unfiltered, including document text and paths with your user name.\n`);
+    }
+    for (const problem of loaded.problems) {
+        process.stderr.write(`[${SERVER_NAME}] config: ${problem}\n`);
+    }
+    process.stderr.write(`[${SERVER_NAME}] ${gate.describe()}\n`);
+    /* Lizenzbedingungen und Support in der Startzeile (A-11 Nr. 3, A-10 Nr. 1). */
+    process.stderr.write(`[${SERVER_NAME}] ${describeProductTerms()}\n`);
+    await startStdioServer(transport, logger, loaded.config, gate);
+}
+/**
+ * Einstieg fuer die Kommandozeile. Aufgerufen von der Startdatei `start.cjs`
+ * (bin, MCPB-Bundle; prueft vorher die Node-Version, E-74) und beim direkten
+ * Start `node dist/src/mcp/server.js` (Handeintrag, bestehende Konfigurationen).
+ */
+export function runCli() {
+    /* Beim direkten Start von server.js hat keine Startdatei geprueft. Laufen die
+       Imports unter Node 18/19 noch durch, soll die Meldung trotzdem die richtige
+       Ursache nennen (E-74). */
+    const problem = nodeVersionProblem(process.version);
+    if (problem !== null) {
+        process.stderr.write(problem);
+        process.exit(1);
+    }
+    main().catch((error) => {
+        process.stderr.write(`[${SERVER_NAME}] fatal: ${String(error)}\n`);
+        process.exit(1);
+    });
+}
+const isEntryPoint = process.argv[1] !== undefined && process.argv[1].endsWith('server.js');
+if (isEntryPoint) {
+    runCli();
+}
+//# sourceMappingURL=server.js.map