layoutbridge-light 0.0.0-stage → 1.0.0

package/dist/src/mcp/catalog.js

@@ -0,0 +1,126 @@
+import { PRODUCT } from './product.js';
+import { TOOLS } from './tools.js';
+/** Die 77 Werkzeuge von LayoutBridge Light (Wahl Sascha 30.10.2026, a), in der Reihenfolge des Katalogs. */
+export const LIGHT_TOOLS = [
+    'get_app_version', 'list_documents', 'open_document', 'close_document', 'create_document', 'save_document',
+    'export_pdf', 'preflight_document', 'document_text_defaults', 'set_document_bleed',
+    'list_pages', 'get_page_state', 'add_page', 'delete_page', 'list_parent_pages', 'create_parent_page',
+    'apply_parent_to_page', 'insert_page_number_marker',
+    'get_layout_grid', 'set_layout_grid',
+    'create_text_frame', 'create_image_frame', 'create_rectangle', 'delete_frame',
+    'set_frame_bounds', 'set_frame_appearance', 'set_frame_columns', 'set_frame_inset', 'set_text_wrap', 'thread_text_frames',
+    'place_image', 'list_links', 'update_links',
+    'get_frame_text', 'set_text', 'set_text_in_range', 'find_replace',
+    'list_paragraph_styles', 'define_paragraph_style', 'define_character_style', 'apply_paragraph_style_to_range', 'apply_character_style_to_range', 'apply_character_format_to_range',
+    'set_paragraph_options', 'get_font_info_at_index', 'find_font_usage', 'debug_inspect_run', 'create_swatch',
+    'get_frame_options', 'list_swatches', 'export_page_image', 'place_text_file', 'fit_frame',
+    'list_stories', 'anchor_frame_in_text', 'list_sections', 'set_section',
+    'set_document_setup', 'list_text_variables', 'create_text_variable', 'insert_text_variable',
+    'save_document_as', 'set_story_options', 'get_frame_lines', 'check_typography',
+    'position_image_in_frame', 'list_toc_styles', 'define_toc_style', 'create_toc', 'add_index_entry', 'list_index', 'generate_index',
+    'check_print_on_demand', 'create_book_cover', 'export_epub', 'check_epub', 'autoflow_story',
+];
+/** Die 46 Werkzeuge, die Light ausdruecklich nicht hat. */
+export const LIGHT_EXCLUDED = [
+    /* Gestaltung */
+    'create_ellipse', 'create_polygon', 'set_corner_options', 'create_gradient_swatch', 'set_frame_effects',
+    'convert_text_to_outlines',
+    /* Fremddokumente und Verknuepfungen */
+    'replace_font', 'replace_swatch', 'embed_link', 'unembed_link', 'delete_link', 'list_pasteboard_items',
+    /* Ebenen, Gruppen, Objektformate */
+    'list_layers', 'set_frame_layer', 'set_layer_visibility', 'group_frames', 'ungroup_frame',
+    'list_object_styles', 'apply_object_style',
+    /* Heftlayout */
+    'move_pages', 'move_pages_to_new_spread', 'move_frame_to_page', 'set_frame_rotation', 'set_frame_stacking',
+    'align_objects', 'list_guides', 'delete_guides', 'clear_frame_content', 'get_selection', 'set_selection',
+    /* Tabellen */
+    'create_table', 'set_table_cells', 'set_table_style', 'get_table',
+    /* Im Buchsatz mit Umweg erledigt (Wahl Sascha 30.10.2026, a) */
+    'duplicate_parent_page', 'override_parent_item_on_page', 'show_page', 'duplicate_frame', 'create_line',
+    'unanchor_frame', 'import_styles', 'package_document', 'relink_links', 'get_image_link_info',
+    'scale_image_in_frame', 'apply_paragraph_style',
+];
+/**
+ * Gezielte Ersetzungen fuer Light: Halbsaetze, die auf ein fehlendes
+ * Werkzeug verweisen, werden gekuerzt, der Rest des Satzes bleibt. Jede
+ * Ersetzung muss im Katalog genau ihren Text finden (Waechtertest) – aendert
+ * sich eine Beschreibung des Vollprodukts, faellt das auf.
+ */
+export const LIGHT_TEXT_REPLACEMENTS = [
+    [' (Ebene; see list_layers for locked or hidden layers)', ' (Ebene)'],
+    ['; repair with move_pages_to_new_spread)', ')'],
+    [' (see list_swatches, create_gradient_swatch)', ' (see list_swatches)'],
+    ['Existing layer to create the object on (see list_layers).', 'Existing layer to create the object on.'],
+    [' Per-corner settings: set_corner_options.', ''],
+    [' – to put it on another page use move_frame_to_page', ''],
+    [' (their graphics would stay behind) – use move_frame_to_page.', ' (their graphics would stay behind).'],
+    [' in its rotated space; set set_frame_rotation 0 first.', ' in its rotated space.'],
+    ["(print: the document's CMYK swatches, see list_swatches, create_gradient_swatch)", "(print: the document's CMYK swatches, see list_swatches)"],
+    [' – delete_link removes it, list_pasteboard_items lists all pasteboard objects.', '.'],
+    ['exact name from list_layers.', 'exact name of an existing layer.'],
+    [', or call show_page.', '.'],
+    [' to stay on the master, or call show_page with one of the page_ids to work on it visibly.', ' to stay on the master.'],
+    [' to switch it off, or build borders from four create_line calls.', ' to switch it off.'],
+    [' – use scale_image_in_frame or fit_frame when', ' – use fit_frame when'],
+    [' – to merely swap the file use relink_links)', ')'],
+    ['check get_image_link_info before repeating.', 'check get_page_state before repeating.'],
+    ['To change the size use scale_image_in_frame or fit_frame.', 'To change the size use fit_frame.'],
+    ['(create_line, create_rectangle, set_frame_appearance,', '(create_rectangle, set_frame_appearance,'],
+];
+/** Einen Text in Saetze teilen (Satzende . ! ? gefolgt von Leerraum). */
+function sentences(text) {
+    return text.split(/(?<=[.!?])\s+/);
+}
+export function mentionsAny(text, names) {
+    return names.some((name) => new RegExp('(^|[^A-Za-z0-9_])' + name + '([^A-Za-z0-9_]|$)').test(text));
+}
+/**
+ * Verweise auf fehlende Werkzeuge entfernen: zuerst die gezielten
+ * Ersetzungen, danach als Rueckfall ganze Saetze, die noch eines nennen.
+ * Bleibt nichts uebrig, gilt der Originaltext (dann schlaegt der
+ * Waechtertest an).
+ */
+export function withoutMentions(text, names) {
+    if (!mentionsAny(text, names))
+        return text;
+    let result = text;
+    for (const [from, to] of LIGHT_TEXT_REPLACEMENTS)
+        result = result.split(from).join(to);
+    if (!mentionsAny(result, names))
+        return result;
+    const kept = sentences(result).filter((sentence) => !mentionsAny(sentence, names));
+    return kept.length === 0 ? text : kept.join(' ');
+}
+/** Ein Parameterschema mit neuer Beschreibung; das Original bleibt unberuehrt. */
+function describedAs(schema, description) {
+    return schema.describe(description);
+}
+/** Eine Kopie der Definition, deren Texte keines der fehlenden Werkzeuge nennen. */
+export function lightDefinition(definition, missing = LIGHT_EXCLUDED) {
+    let shapeChanged = false;
+    const shape = {};
+    for (const [key, schema] of Object.entries(definition.inputShape)) {
+        const current = schema.description;
+        if (typeof current === 'string' && mentionsAny(current, missing)) {
+            shape[key] = describedAs(schema, withoutMentions(current, missing));
+            shapeChanged = true;
+        }
+        else {
+            shape[key] = schema;
+        }
+    }
+    const description = withoutMentions(definition.description, missing);
+    if (!shapeChanged && description === definition.description)
+        return definition;
+    return { ...definition, description, inputShape: shapeChanged ? shape : definition.inputShape };
+}
+/** Der Katalog eines Produkts. */
+export function catalogFor(product = PRODUCT, tools = TOOLS) {
+    if (product.id !== 'light')
+        return [...tools];
+    const allowed = new Set(LIGHT_TOOLS);
+    return tools.filter((tool) => allowed.has(tool.name)).map((tool) => lightDefinition(tool));
+}
+/** Der Katalog dieses Pakets. */
+export const CATALOG = catalogFor();
+//# sourceMappingURL=catalog.js.map

package/dist/src/mcp/config.js

@@ -0,0 +1,211 @@
+/**
+ * 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';
+import { envName, PRODUCT } from './product.js';
+const KNOWN_KEYS = ['tracking_warn_beyond', 'min_ppi', 'export_pdf', 'print_on_demand', 'epub'];
+const POD_NUMBER_KEYS = [
+    ['min_page_count', 1], ['max_page_count', 1], ['page_count_multiple', 1], ['min_outside_margin_mm', 0], ['bleed_mm', 0],
+    ['min_font_size_pt', 0], ['spine_per_page_mm', 0], ['safety_margin_mm', 0], ['spine_safety_mm', 0],
+];
+const KNOWN_POD_KEYS = [...POD_NUMBER_KEYS.map(([key]) => key), 'inside_margin_tiers', 'barcode_area'];
+const BARCODE_KEYS = ['width_mm', 'height_mm', 'offset_x_mm', 'offset_y_mm'];
+const KNOWN_PDF_KEYS = ['preset', 'fallback_preset', 'fallback_over_bytes'];
+export function defaultConfigPath(env = process.env, os = platform(), home = homedir(), product = PRODUCT) {
+    const fromEnv = env[envName('CONFIG', product)];
+    if (fromEnv !== undefined && fromEnv.length > 0)
+        return fromEnv;
+    if (os === 'darwin') {
+        return join(home, 'Library', 'Application Support', product.dataDirName, 'config.json');
+    }
+    return join(home, '.' + product.dataDirName, '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;
+        }
+    }
+    if (raw['print_on_demand'] !== undefined) {
+        const pod = parsePrintOnDemand(raw['print_on_demand'], problems);
+        if (pod !== undefined)
+            config.print_on_demand = pod;
+    }
+    if (raw['epub'] !== undefined) {
+        const epub = raw['epub'];
+        if (!isRecord(epub)) {
+            problems.push('epub: expected an object');
+        }
+        else {
+            for (const key of Object.keys(epub)) {
+                if (key !== 'min_ppi')
+                    problems.push(`unknown key "epub.${key}" ignored`);
+            }
+            const minPpi = takeNumber(epub, 'min_ppi', 1, problems, 'epub.');
+            config.epub = minPpi === undefined ? {} : { min_ppi: minPpi };
+        }
+    }
+    return { config, problems };
+}
+function parsePrintOnDemand(value, problems) {
+    const prefix = 'print_on_demand.';
+    if (!isRecord(value)) {
+        problems.push('print_on_demand: expected an object');
+        return undefined;
+    }
+    for (const key of Object.keys(value)) {
+        if (!KNOWN_POD_KEYS.includes(key))
+            problems.push(`unknown key "${prefix}${key}" ignored`);
+    }
+    const out = {};
+    for (const [key, min] of POD_NUMBER_KEYS) {
+        const n = takeNumber(value, key, min, problems, prefix);
+        if (n !== undefined)
+            out[key] = n;
+    }
+    if (value['inside_margin_tiers'] !== undefined) {
+        const tiers = value['inside_margin_tiers'];
+        const parsed = [];
+        if (!Array.isArray(tiers)) {
+            problems.push(`${prefix}inside_margin_tiers: expected an array of {max_pages, min_mm}`);
+        }
+        else {
+            tiers.forEach((tier, index) => {
+                const at = `${prefix}inside_margin_tiers[${index}].`;
+                if (!isRecord(tier)) {
+                    problems.push(`${at.slice(0, -1)}: expected an object {max_pages, min_mm}`);
+                    return;
+                }
+                const maxPages = takeNumber(tier, 'max_pages', 1, problems, at);
+                const minMm = takeNumber(tier, 'min_mm', 0, problems, at);
+                if (maxPages !== undefined && minMm !== undefined)
+                    parsed.push({ max_pages: maxPages, min_mm: minMm });
+                else if (tier['max_pages'] === undefined || tier['min_mm'] === undefined)
+                    problems.push(`${at}: max_pages and min_mm are both required`);
+            });
+            if (parsed.length > 0)
+                out.inside_margin_tiers = parsed;
+        }
+    }
+    if (value['barcode_area'] !== undefined) {
+        const area = value['barcode_area'];
+        if (!isRecord(area)) {
+            problems.push(`${prefix}barcode_area: expected an object {width_mm, height_mm, offset_x_mm, offset_y_mm}`);
+        }
+        else {
+            const parsed = {};
+            for (const key of BARCODE_KEYS) {
+                const n = takeNumber(area, key, 0, problems, `${prefix}barcode_area.`);
+                if (n !== undefined)
+                    parsed[key] = n;
+            }
+            if (BARCODE_KEYS.every((key) => parsed[key] !== undefined))
+                out.barcode_area = parsed;
+            else
+                problems.push(`${prefix}barcode_area: width_mm, height_mm, offset_x_mm and offset_y_mm are all required`);
+        }
+    }
+    return out;
+}
+/** 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,164 @@
+/**
+ * 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;
+}
+/**
+ * Sitzung 38 (A-22): Pfade der Redaktionsdateien (`managed_file`, in
+ * list_stories, get_frame_text, find_replace.skipped_locked[]) mit "~" statt
+ * des Benutzerverzeichnisses – wie die Fehlerantworten (E-68). Nur dieses
+ * Feld; andere Felder (Text, Pfade anderer Werkzeuge) bleiben unveraendert.
+ */
+export function maskManagedFiles(result, home = homedir()) {
+    return maskManagedDeep(result, home, 0);
+}
+function maskManagedDeep(value, home, depth) {
+    if (depth >= 6)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => maskManagedDeep(item, home, depth + 1));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const key of Object.keys(value)) {
+            const entry = value[key];
+            out[key] = key === 'managed_file' && typeof entry === 'string' ? maskHome(entry, home) : maskManagedDeep(entry, 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 {
+        /* Sitzung 60 (E-102): Werkzeuge mit lokalem Teil antworten ohne InDesign, wenn local ein Ergebnis liefert. */
+        const local = definition.local ? definition.local(built.command.args) : undefined;
+        if (local !== undefined) {
+            result = local;
+        }
+        else {
+            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;
+    if (result.ok && definition.after) {
+        try {
+            result = definition.after(built.command.args, result);
+        }
+        catch (error) {
+            result = { ...result, warnings: [...(Array.isArray(result.warnings) ? result.warnings : []), 'Post-processing failed: ' + String(error)] };
+        }
+    }
+    result = maskErrorPaths(result);
+    if (result.ok)
+        result = maskManagedFiles(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