layoutbridge-light 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+import { PRODUCT } from './product.js';
+/**
+ * Seit A-70 (E-109) haengen die Adressen am Produktprofil: das Vollprodukt
+ * unter /layoutbridge/ (unveraendert), LayoutBridge Light unter
+ * /layoutbridge-light/ mit denselben Dateinamen.
+ */
+/** 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/' + PRODUCT.pagePath + '/license.html';
+export const LICENSE_TERMS_URL_DE = 'https://mcp-schnittstellen.de/' + PRODUCT.pagePath + '/lizenzbedingungen.html';
+/** Datenschutzerklaerung des Produkts, englisch und deutsch; dazu die des Zahlungsdienstes. */
+export const PRIVACY_POLICY_URL = 'https://mcp-interfaces.com/' + PRODUCT.pagePath + '/privacy.html';
+export const PRIVACY_POLICY_URL_DE = 'https://mcp-schnittstellen.de/' + PRODUCT.pagePath + '/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/' + PRODUCT.pagePath + '/';
+export const PRODUCT_PAGE_URL_DE = 'https://mcp-schnittstellen.de/' + PRODUCT.pagePath + '/';
+/** 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/product.js

@@ -0,0 +1,56 @@
+/**
+ * Produktprofil (A-70, Vermerk E-109, 30.10.2026).
+ *
+ * Aus derselben Codebasis entstehen zwei Produkte: das Vollprodukt
+ * `layoutbridge-spm` (alle Werkzeuge) und **LayoutBridge Light**
+ * (`layoutbridge-light`, Buchsatz, eine feste Teilmenge der Werkzeuge).
+ * Welches Produkt laeuft, bestimmt allein der Name in der package.json des
+ * ausgelieferten Pakets – das Light-Paket wird von scripts/light-package.mjs
+ * mit eigenem Namen gebaut. Es gibt keinen Schalter fuer Kunden: weder
+ * config.json noch eine Umgebungsvariable waehlen das Produkt.
+ *
+ * Das Profil des Vollprodukts gibt exakt die bisherigen Werte wieder
+ * (Namen, Ordner, Umgebungsvariablen, Adressen); fuer das Vollprodukt aendert
+ * sich nichts (E-79).
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const FULL_PRODUCT = {
+    id: 'full',
+    packageName: 'layoutbridge-spm',
+    displayName: 'LayoutBridge for Adobe InDesign®',
+    dataDirName: 'layoutbridge-spm',
+    envPrefix: 'LAYOUTBRIDGE_SPM',
+    pagePath: 'layoutbridge',
+};
+export const LIGHT_PRODUCT = {
+    id: 'light',
+    packageName: 'layoutbridge-light',
+    displayName: 'LayoutBridge Light for Adobe InDesign®',
+    dataDirName: 'layoutbridge-light',
+    envPrefix: 'LAYOUTBRIDGE_LIGHT',
+    pagePath: 'layoutbridge-light',
+};
+export const PRODUCTS = [FULL_PRODUCT, LIGHT_PRODUCT];
+/** Profil zu einem Paketnamen; alles Unbekannte ist das Vollprodukt (Entwicklung im Repo). */
+export function productForPackageName(name) {
+    return name === LIGHT_PRODUCT.packageName ? LIGHT_PRODUCT : FULL_PRODUCT;
+}
+function readPackageName() {
+    try {
+        const packageJson = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+        const parsed = JSON.parse(readFileSync(packageJson, 'utf8'));
+        return parsed.name;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Das Produkt dieses Pakets – einmal beim Laden bestimmt. */
+export const PRODUCT = productForPackageName(readPackageName());
+/** Name einer Umgebungsvariablen dieses Produkts, z. B. envName('LICENSE_KEY'). */
+export function envName(suffix, product = PRODUCT) {
+    return product.envPrefix + '_' + suffix;
+}
+//# sourceMappingURL=product.js.map

package/dist/src/mcp/server.js

@@ -0,0 +1,253 @@
+#!/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 { maskErrorPaths, 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 { CATALOG } from './catalog.js';
+import { PRODUCT } from './product.js';
+import { nodeVersionProblem } from './start.cjs';
+import { ComTransport } from '../transport/com.js';
+import { OsascriptTransport } from '../transport/osascript.js';
+import { SerialTransport } from '../transport/queue.js';
+/** Servername = npm-Paket des Produkts (A-70, E-109; Vollprodukt unveraendert layoutbridge-spm). */
+export const SERVER_NAME = PRODUCT.packageName;
+/**
+ * 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 CATALOG) {
+        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) {
+                        /* Wie jede Fehlerantwort ohne Benutzerverzeichnis (E-68, Befund 1 aus Sitzung 33). */
+                        const refused = maskErrorPaths(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({ dataDirName: PRODUCT.dataDirName }) : 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, ${CATALOG.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