layoutbridge-light 0.0.0-stage → 1.0.1

package/dist/src/mcp/epub-check.js

@@ -0,0 +1,331 @@
+/**
+ * Sitzung 60 (A-45 Punkt 1, E-102): Pruefung einer fertigen EPUB-Datei ohne
+ * InDesign – fuer check_epub mit path. Liest das ZIP selbst (zentrales
+ * Verzeichnis, Methoden stored/deflate ueber node:zlib), dann
+ * META-INF/container.xml, das OPF-Paket und die Verweise der
+ * XHTML-Dateien. Grundlage: EPUB-OCF (mimetype als erster Eintrag,
+ * unkomprimiert), EPUB-Paketdokument (dc:title, dc:language, dc:identifier,
+ * nav bzw. NCX) und die Funde an InDesign-21.6-Exporten vom 23.10.2026
+ * (docs/EPUB-ANFORDERUNGEN.md). Ersetzt EPUBCheck nicht.
+ */
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { posix } from 'node:path';
+import { inflateRawSync } from 'node:zlib';
+import { transportError } from '../transport/transport.js';
+const MIMETYPE = 'application/epub+zip';
+/** Liest das zentrale Verzeichnis eines ZIP-Archivs. Wirft bei kaputtem Archiv. */
+export function readZipEntries(buffer) {
+    const minEnd = Math.max(0, buffer.length - 65_557);
+    let end = -1;
+    for (let i = buffer.length - 22; i >= minEnd; i--) {
+        if (buffer.readUInt32LE(i) === 0x06054b50) {
+            end = i;
+            break;
+        }
+    }
+    if (end < 0)
+        throw new Error('no ZIP end-of-central-directory record');
+    const count = buffer.readUInt16LE(end + 10);
+    let offset = buffer.readUInt32LE(end + 16);
+    if (count === 0xffff || offset === 0xffffffff)
+        throw new Error('ZIP64 archives are not supported');
+    const entries = [];
+    for (let n = 0; n < count; n++) {
+        if (offset + 46 > buffer.length || buffer.readUInt32LE(offset) !== 0x02014b50)
+            throw new Error('broken central directory');
+        const method = buffer.readUInt16LE(offset + 10);
+        const compressedSize = buffer.readUInt32LE(offset + 20);
+        const size = buffer.readUInt32LE(offset + 24);
+        const nameLength = buffer.readUInt16LE(offset + 28);
+        const extraLength = buffer.readUInt16LE(offset + 30);
+        const commentLength = buffer.readUInt16LE(offset + 32);
+        const localOffset = buffer.readUInt32LE(offset + 42);
+        const name = buffer.toString('utf8', offset + 46, offset + 46 + nameLength);
+        entries.push({
+            name, method, compressedSize, size, localOffset,
+            crc: buffer.readUInt32LE(offset + 16), time: buffer.readUInt16LE(offset + 12), date: buffer.readUInt16LE(offset + 14),
+        });
+        offset += 46 + nameLength + extraLength + commentLength;
+    }
+    return entries;
+}
+function localHeader(buffer, entry) {
+    const at = entry.localOffset;
+    if (at + 30 > buffer.length || buffer.readUInt32LE(at) !== 0x04034b50)
+        throw new Error('broken local header for ' + entry.name);
+    const nameLength = buffer.readUInt16LE(at + 26);
+    const extraLength = buffer.readUInt16LE(at + 28);
+    return { dataStart: at + 30 + nameLength + extraLength, extraLength, name: buffer.toString('utf8', at + 30, at + 30 + nameLength) };
+}
+/** Die gespeicherten (ggf. komprimierten) Bytes eines Eintrags, unverändert. */
+export function rawZipEntry(buffer, entry) {
+    const { dataStart } = localHeader(buffer, entry);
+    return Buffer.from(buffer.subarray(dataStart, dataStart + entry.compressedSize));
+}
+/** Inhalt eines Eintrags (stored oder deflate). */
+export function readZipEntry(buffer, entry) {
+    const { dataStart } = localHeader(buffer, entry);
+    const data = buffer.subarray(dataStart, dataStart + entry.compressedSize);
+    if (entry.method === 0)
+        return Buffer.from(data);
+    if (entry.method === 8)
+        return inflateRawSync(data);
+    throw new Error('unsupported compression method ' + entry.method + ' in ' + entry.name);
+}
+function attr(tag, name) {
+    const match = new RegExp('\\s' + name.replace(':', '\\:') + '\\s*=\\s*("([^"]*)"|\'([^\']*)\')', 'i').exec(tag);
+    if (match === null)
+        return null;
+    return match[2] ?? match[3] ?? '';
+}
+function decodeXml(text) {
+    return text
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function elementTexts(xml, qname) {
+    const out = [];
+    const re = new RegExp('<' + qname + '(\\s[^>]*)?>([\\s\\S]*?)</' + qname + '>', 'gi');
+    for (const match of xml.matchAll(re))
+        out.push(decodeXml((match[2] ?? '').trim()));
+    return out;
+}
+/** Verweis relativ zu einer Datei im Archiv aufloesen (ohne Fragment, dekodiert). */
+function resolveRef(fromFile, ref) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(ref) || ref.startsWith('#') || ref.startsWith('//'))
+        return null;
+    const withoutFragment = ref.split('#')[0].split('?')[0];
+    if (withoutFragment === '')
+        return null;
+    let decoded = withoutFragment;
+    try {
+        decoded = decodeURIComponent(withoutFragment);
+    }
+    catch {
+        /* bleibt roh */
+    }
+    return posix.normalize(posix.join(posix.dirname(fromFile), decoded));
+}
+function expandHome(path) {
+    if (path === '~')
+        return homedir();
+    if (path.startsWith('~/'))
+        return homedir() + path.slice(1);
+    return path;
+}
+/** Prueft eine EPUB-Datei. Ergebnis im Umschlag der Werkzeuge (ok, warnings, …). */
+export function checkEpubFile(path, options = {}) {
+    const file = expandHome(path);
+    if (!existsSync(file))
+        return transportError('not_found', 'The file does not exist: ' + path, { code: 'file_not_found', path });
+    let buffer;
+    try {
+        if (!statSync(file).isFile())
+            return transportError('invalid_argument', 'path is not a file: ' + path, { path });
+        buffer = readFileSync(file);
+    }
+    catch (error) {
+        return transportError('io_error', 'Cannot read the file: ' + String(error), { path });
+    }
+    const max = options.maxFindings ?? 200;
+    const findings = [];
+    let total = 0;
+    let errors = 0;
+    const checksRun = [];
+    const add = (check, severity, fileName, hint) => {
+        total += 1;
+        if (severity === 'error')
+            errors += 1;
+        if (findings.length < max)
+            findings.push({ check, severity, file: fileName, hint });
+    };
+    const result = (extra) => {
+        const warnings = [];
+        if (total > findings.length)
+            warnings.push(total + ' findings, only the first ' + findings.length + ' returned (max_findings).');
+        return {
+            ok: true,
+            warnings,
+            passed: errors === 0,
+            checked: 'file',
+            path,
+            bytes: buffer.length,
+            checks_run: checksRun,
+            errors,
+            findings,
+            findings_total: total,
+            findings_truncated: total > findings.length,
+            ...extra,
+        };
+    };
+    /* 1. ZIP-Aufbau */
+    checksRun.push('zip_structure');
+    let entries;
+    try {
+        entries = readZipEntries(buffer);
+    }
+    catch (error) {
+        add('zip_structure', 'error', null, 'Not a readable ZIP archive: ' + (error instanceof Error ? error.message : String(error)) + '.');
+        return result({});
+    }
+    const byName = new Map(entries.map((entry) => [entry.name, entry]));
+    const read = (name) => {
+        const entry = byName.get(name);
+        if (entry === undefined)
+            return null;
+        try {
+            return readZipEntry(buffer, entry).toString('utf8');
+        }
+        catch (error) {
+            add('zip_structure', 'error', name, 'Cannot read this entry: ' + (error instanceof Error ? error.message : String(error)) + '.');
+            return null;
+        }
+    };
+    const first = entries.slice().sort((a, b) => a.localOffset - b.localOffset)[0];
+    if (first === undefined || first.name !== 'mimetype') {
+        add('zip_structure', 'error', first?.name ?? null, 'The first entry of the archive must be "mimetype".');
+    }
+    else {
+        if (first.method !== 0)
+            add('zip_structure', 'error', 'mimetype', 'The mimetype entry must be stored uncompressed.');
+        try {
+            if (localHeader(buffer, first).extraLength !== 0)
+                add('zip_structure', 'warning', 'mimetype', 'The mimetype entry carries an extra field; EPUB readers expect none.');
+        }
+        catch {
+            add('zip_structure', 'error', 'mimetype', 'Broken local header of the mimetype entry.');
+        }
+        const mime = read('mimetype');
+        if (mime !== null && mime !== MIMETYPE)
+            add('zip_structure', 'error', 'mimetype', 'The mimetype entry must contain exactly "' + MIMETYPE + '".');
+    }
+    /* 2. container.xml */
+    checksRun.push('container');
+    const container = read('META-INF/container.xml');
+    if (container === null) {
+        add('container', 'error', 'META-INF/container.xml', 'META-INF/container.xml is missing.');
+        return result({ file_count: entries.length });
+    }
+    const rootTag = /<rootfile\b[^>]*>/i.exec(container)?.[0] ?? '';
+    const opfPath = attr(rootTag, 'full-path');
+    if (opfPath === null || opfPath === '') {
+        add('container', 'error', 'META-INF/container.xml', 'No rootfile full-path in container.xml.');
+        return result({ file_count: entries.length });
+    }
+    const opf = read(opfPath);
+    if (opf === null) {
+        add('container', 'error', opfPath, 'The package document named in container.xml is missing.');
+        return result({ file_count: entries.length });
+    }
+    /* 3. Metadaten */
+    checksRun.push('opf_metadata');
+    const packageTag = /<package\b[^>]*>/i.exec(opf)?.[0] ?? '';
+    const version = attr(packageTag, 'version');
+    const uniqueId = attr(packageTag, 'unique-identifier');
+    const titles = elementTexts(opf, 'dc:title');
+    const languages = elementTexts(opf, 'dc:language');
+    const creators = elementTexts(opf, 'dc:creator');
+    const identifierTags = [...opf.matchAll(/<dc:identifier(\s[^>]*)?>([\s\S]*?)<\/dc:identifier>/gi)];
+    const identifiers = identifierTags.map((match) => decodeXml((match[2] ?? '').trim()));
+    if (version === null)
+        add('opf_metadata', 'error', opfPath, 'The package element has no version.');
+    if (titles.length === 0 || titles.every((t) => t === ''))
+        add('opf_metadata', 'error', opfPath, 'dc:title is missing.');
+    if (languages.length === 0 || languages.every((t) => t === ''))
+        add('opf_metadata', 'error', opfPath, 'dc:language is missing.');
+    if (identifiers.length === 0)
+        add('opf_metadata', 'error', opfPath, 'dc:identifier is missing.');
+    else if (uniqueId !== null && !identifierTags.some((match) => attr(match[0], 'id') === uniqueId)) {
+        add('opf_metadata', 'error', opfPath, 'unique-identifier "' + uniqueId + '" names no dc:identifier.');
+    }
+    if (creators.length === 0)
+        add('opf_metadata', 'warning', opfPath, 'No dc:creator (author).');
+    /* 4. Manifest und Spine */
+    checksRun.push('manifest_files');
+    const opfDir = posix.dirname(opfPath);
+    const manifest = new Map();
+    for (const match of opf.matchAll(/<item\b[^>]*>/gi)) {
+        const tag = match[0];
+        const id = attr(tag, 'id') ?? '';
+        const href = decodeXml(attr(tag, 'href') ?? '');
+        const full = resolveRef(opfPath, href) ?? posix.join(opfDir, href);
+        manifest.set(id, { href, full, mediaType: attr(tag, 'media-type') ?? '', properties: attr(tag, 'properties') ?? '' });
+        if (href === '' || !byName.has(full))
+            add('manifest_files', 'error', full, 'The manifest names a file that is not in the archive.');
+    }
+    for (const match of opf.matchAll(/<itemref\b[^>]*>/gi)) {
+        const idref = attr(match[0], 'idref') ?? '';
+        if (!manifest.has(idref))
+            add('manifest_files', 'error', opfPath, 'The spine refers to "' + idref + '", which is not in the manifest.');
+    }
+    /* 5. Navigation */
+    checksRun.push('navigation');
+    const nav = [...manifest.values()].find((item) => item.properties.split(/\s+/).includes('nav'));
+    const spineTag = /<spine\b[^>]*>/i.exec(opf)?.[0] ?? '';
+    const ncxId = attr(spineTag, 'toc');
+    const ncx = ncxId === null ? undefined : manifest.get(ncxId);
+    const isEpub3 = version !== null && version.startsWith('3');
+    if (isEpub3 && nav === undefined)
+        add('navigation', 'error', opfPath, 'EPUB 3 needs a navigation document (manifest item with properties "nav").');
+    if (!isEpub3 && ncx === undefined)
+        add('navigation', 'error', opfPath, 'EPUB 2 needs an NCX table of contents (spine toc).');
+    let navEntries = null;
+    if (nav !== undefined) {
+        const navText = read(nav.full);
+        if (navText !== null) {
+            const tocNav = /<nav\b[^>]*epub:type\s*=\s*"[^"]*\btoc\b[^"]*"[^>]*>([\s\S]*?)<\/nav>/i.exec(navText);
+            navEntries = tocNav === null ? 0 : [...(tocNav[1] ?? '').matchAll(/<a\b/gi)].length;
+            if (tocNav === null)
+                add('navigation', 'error', nav.full, 'The navigation document has no toc nav.');
+        }
+    }
+    /* 6. Verweise in den Inhaltsdateien */
+    checksRun.push('references');
+    for (const item of manifest.values()) {
+        if (!/xhtml|html/i.test(item.mediaType) || !byName.has(item.full))
+            continue;
+        const text = read(item.full);
+        if (text === null)
+            continue;
+        for (const match of text.matchAll(/\s(src|href)\s*=\s*"([^"]*)"/gi)) {
+            const target = resolveRef(item.full, decodeXml(match[2] ?? ''));
+            if (target === null)
+                continue;
+            if (!byName.has(target))
+                add('references', 'error', item.full, '"' + (match[2] ?? '') + '" points to a file that is not in the archive.');
+        }
+    }
+    /* 7. Cover und Layout */
+    checksRun.push('cover');
+    const coverItem = [...manifest.values()].find((item) => item.properties.split(/\s+/).includes('cover-image'));
+    const coverMeta = /<meta\b[^>]*name\s*=\s*"cover"[^>]*>/i.exec(opf);
+    const coverMetaId = coverMeta === null ? null : attr(coverMeta[0], 'content');
+    const coverByMeta = coverMetaId === null ? undefined : manifest.get(coverMetaId);
+    const cover = coverItem ?? coverByMeta;
+    if (cover === undefined)
+        add('cover', 'warning', opfPath, 'No cover image inside the EPUB (manifest property "cover-image" or meta name="cover").');
+    const prepaginated = /<meta\b[^>]*property\s*=\s*"rendition:layout"[^>]*>\s*pre-paginated\s*</i.test(opf);
+    const fonts = [...manifest.values()].filter((item) => /font|opentype|truetype|woff/i.test(item.mediaType)).map((item) => item.full);
+    return result({
+        epub_version: version,
+        layout: prepaginated ? 'fixed_layout' : 'reflowable',
+        package_document: opfPath,
+        title: titles[0] ?? null,
+        language: languages[0] ?? null,
+        creators,
+        identifiers,
+        file_count: entries.length,
+        manifest_items: manifest.size,
+        nav_document: nav?.full ?? null,
+        nav_entries: navEntries,
+        ncx: ncx?.full ?? null,
+        cover_image: cover?.full ?? null,
+        fonts,
+        fonts_obfuscated: byName.has('META-INF/encryption.xml'),
+    });
+}
+//# sourceMappingURL=epub-check.js.map

package/dist/src/mcp/epub-orientation.js

@@ -0,0 +1,132 @@
+/**
+ * A-62 (Sitzung 60, Nachtrag, E-104): Ausrichtung eines fixed-layout-EPUB
+ * nach dem Export setzen. InDesign 21.6 schreibt `rendition:orientation
+ * landscape` auch bei Hochformatseiten; Kindle Previewer 4 sperrt das Buch
+ * dann auf Querformat (Befund 23.10.2026). Das DOM bietet dafür keine
+ * Einstellung (Probe 23.10.2026). Deshalb wird im Paketdokument (OPF) der
+ * Wert ersetzt und das Archiv neu geschrieben: mimetype zuerst und
+ * unkomprimiert, alle anderen Einträge byte-gleich übernommen, nur das OPF
+ * neu komprimiert. Die Datei wird über eine Zwischendatei ersetzt.
+ */
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { deflateRawSync } from 'node:zlib';
+import { rawZipEntry, readZipEntries, readZipEntry } from './epub-check.js';
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+export function crc32(data) {
+    let c = 0xffffffff;
+    for (let i = 0; i < data.length; i++)
+        c = CRC_TABLE[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** Schreibt ein ZIP ohne Datendeskriptoren und ohne Zusatzfelder (UTF-8-Namen). */
+export function writeZip(entries) {
+    const parts = [];
+    const central = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name, 'utf8');
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6);
+        local.writeUInt16LE(entry.method, 8);
+        local.writeUInt16LE(entry.time, 10);
+        local.writeUInt16LE(entry.date, 12);
+        local.writeUInt32LE(entry.crc, 14);
+        local.writeUInt32LE(entry.data.length, 18);
+        local.writeUInt32LE(entry.size, 22);
+        local.writeUInt16LE(name.length, 26);
+        parts.push(local, name, entry.data);
+        const cd = Buffer.alloc(46);
+        cd.writeUInt32LE(0x02014b50, 0);
+        cd.writeUInt16LE(20, 4);
+        cd.writeUInt16LE(20, 6);
+        cd.writeUInt16LE(0x0800, 8);
+        cd.writeUInt16LE(entry.method, 10);
+        cd.writeUInt16LE(entry.time, 12);
+        cd.writeUInt16LE(entry.date, 14);
+        cd.writeUInt32LE(entry.crc, 16);
+        cd.writeUInt32LE(entry.data.length, 20);
+        cd.writeUInt32LE(entry.size, 24);
+        cd.writeUInt16LE(name.length, 28);
+        cd.writeUInt32LE(offset, 42);
+        central.push(cd, name);
+        offset += 30 + name.length + entry.data.length;
+    }
+    const cdBuffer = Buffer.concat(central);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(cdBuffer.length, 12);
+    end.writeUInt32LE(offset, 16);
+    return Buffer.concat([...parts, cdBuffer, end]);
+}
+/** Setzt rendition:orientation im OPF-Text; fehlt die Angabe, kommt sie hinter rendition:layout. */
+export function setOrientationInOpf(opf, value) {
+    const re = /(<meta\b[^>]*property\s*=\s*"rendition:orientation"[^>]*>)\s*([^<]*?)\s*(<\/meta>)/i;
+    const found = re.exec(opf);
+    if (found !== null) {
+        return { opf: opf.replace(re, '$1' + value + '$3'), previous: found[2] ?? '' };
+    }
+    const layout = /(<meta\b[^>]*property\s*=\s*"rendition:layout"[^>]*>[^<]*<\/meta>)/i;
+    if (layout.test(opf)) {
+        return { opf: opf.replace(layout, '$1\n\t\t<meta property="rendition:orientation">' + value + '</meta>'), previous: null };
+    }
+    return { opf: opf.replace(/<\/metadata>/i, '\t<meta property="rendition:orientation">' + value + '</meta>\n\t</metadata>'), previous: null };
+}
+/** Ausrichtung in einer EPUB-Datei setzen. Wirft bei unlesbarem Archiv oder fehlendem OPF. */
+export function setEpubOrientation(path, value) {
+    const buffer = readFileSync(path);
+    const entries = readZipEntries(buffer).sort((a, b) => a.localOffset - b.localOffset);
+    const byName = new Map(entries.map((entry) => [entry.name, entry]));
+    const container = byName.get('META-INF/container.xml');
+    if (container === undefined)
+        throw new Error('META-INF/container.xml is missing');
+    const containerText = readZipEntry(buffer, container).toString('utf8');
+    const opfPath = /full-path\s*=\s*"([^"]+)"/i.exec(containerText)?.[1];
+    const opfEntry = opfPath === undefined ? undefined : byName.get(opfPath);
+    if (opfEntry === undefined)
+        throw new Error('package document not found');
+    const before = readZipEntry(buffer, opfEntry).toString('utf8');
+    const { opf, previous } = setOrientationInOpf(before, value);
+    if (opf === before)
+        return { value, previous, changed: false, bytes: buffer.length };
+    const mime = byName.get('mimetype');
+    const ordered = mime === undefined ? entries : [mime, ...entries.filter((entry) => entry !== mime)];
+    const out = ordered.map((entry) => {
+        if (entry === opfEntry) {
+            const raw = Buffer.from(opf, 'utf8');
+            return { name: entry.name, method: 8, crc: crc32(raw), size: raw.length, data: deflateRawSync(raw), time: entry.time, date: entry.date };
+        }
+        if (entry === mime) {
+            const raw = readZipEntry(buffer, entry);
+            return { name: entry.name, method: 0, crc: crc32(raw), size: raw.length, data: raw, time: entry.time, date: entry.date };
+        }
+        return { name: entry.name, method: entry.method, crc: entry.crc, size: entry.size, data: rawZipEntry(buffer, entry), time: entry.time, date: entry.date };
+    });
+    const result = writeZip(out);
+    const temp = path + '.tmp-orientation';
+    writeFileSync(temp, result);
+    try {
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temp);
+        }
+        catch { /* bleibt liegen */ }
+        throw error;
+    }
+    return { value, previous, changed: true, bytes: result.length };
+}
+//# sourceMappingURL=epub-orientation.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