@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/tools/docx/modify.js

@@ -1,271 +0,0 @@
-/**
- * Legacy DOCX modification operations.
- *
- * These functions support the older write_file / edit_block paths that
- * modify DOCX via simple operations (replace, insert, delete, style).
- * They are distinct from the new patch-based writeDocxPatched pipeline.
- *
- * Single Responsibility: create / modify DOCX content using the legacy
- * DocxModification interface.  Delegates XML parsing and element
- * manipulation to the shared dom.ts module.
- */
-import fs from 'fs/promises';
-import path from 'path';
-import os from 'os';
-import PizZip from 'pizzip';
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import { nodeListToArray, getParagraphText, setParagraphTextMinimal, colorParagraphRuns, styleParagraphRuns, } from './dom.js';
-// ═══════════════════════════════════════════════════════════════════════
-// Helpers (private to this module)
-// ═══════════════════════════════════════════════════════════════════════
-/** Get all direct w:p children of body in document order. */
-function getParagraphs(body) {
-    const paragraphs = [];
-    for (const child of nodeListToArray(body.childNodes)) {
-        if (child.nodeType === 1 && child.nodeName === 'w:p') {
-            paragraphs.push(child);
-        }
-    }
-    return paragraphs;
-}
-/** Parse DOCX and return { zip, dom, body }. */
-function parseDocument(inputBuf) {
-    const zip = new PizZip(inputBuf);
-    const docFile = zip.file('word/document.xml');
-    if (!docFile)
-        throw new Error('Invalid DOCX: missing word/document.xml');
-    const dom = new DOMParser().parseFromString(docFile.asText(), 'application/xml');
-    const body = dom.getElementsByTagName('w:body').item(0);
-    if (!body)
-        throw new Error('Invalid DOCX: missing w:body');
-    return { zip, dom, body };
-}
-// ═══════════════════════════════════════════════════════════════════════
-// modifyDocxContent — apply legacy modifications
-// ═══════════════════════════════════════════════════════════════════════
-/**
- * Open an existing DOCX, apply an ordered list of modifications to
- * word/document.xml, and write the result to outputPath.
- * Every other file in the ZIP (styles, images, rels, …) is preserved.
- */
-export async function modifyDocxContent(inputPath, outputPath, modifications) {
-    const inputBuf = await fs.readFile(inputPath);
-    const { zip, dom, body } = parseDocument(inputBuf);
-    for (const mod of modifications) {
-        switch (mod.type) {
-            case 'replace':
-                applyReplace(body, mod);
-                break;
-            case 'insert':
-                applyInsert(body, mod);
-                break;
-            case 'delete':
-                applyDelete(body, mod);
-                break;
-            case 'style':
-                applyStyle(body, mod);
-                break;
-        }
-    }
-    const outXml = new XMLSerializer().serializeToString(dom);
-    zip.file('word/document.xml', outXml);
-    const outBuf = zip.generate({ type: 'nodebuffer' });
-    await fs.writeFile(outputPath, outBuf);
-}
-// ═══════════════════════════════════════════════════════════════════════
-// replaceBodyXml — wholesale body replacement
-// ═══════════════════════════════════════════════════════════════════════
-/**
- * Replace the entire w:body content of a DOCX with new body XML.
- * Used by the body-XML replacement mode of write_file.
- */
-export async function replaceBodyXml(inputPath, outputPath, newBodyXml) {
-    const tempDir = os.tmpdir();
-    const tempDocxPath = path.join(tempDir, `docx_temp_${Date.now()}_${Math.random().toString(36).substring(7)}.docx`);
-    const tempXmlPath = path.join(tempDir, `docx_dom_${Date.now()}_${Math.random().toString(36).substring(7)}.xml`);
-    try {
-        const inputBuf = await fs.readFile(inputPath);
-        await fs.writeFile(tempDocxPath, inputBuf);
-        const { zip, dom, body } = parseDocument(inputBuf);
-        await fs.writeFile(tempXmlPath, zip.file('word/document.xml').asText());
-        // Parse the new body XML
-        const newBodyDom = new DOMParser().parseFromString(`<root>${newBodyXml}</root>`, 'application/xml');
-        const newBodyElement = newBodyDom.documentElement.firstChild;
-        if (!newBodyElement || newBodyElement.nodeName !== 'w:body') {
-            throw new Error('Invalid body XML: must start with <w:body>');
-        }
-        // Import children from new body into original document
-        const doc = body.ownerDocument;
-        if (!doc)
-            throw new Error('Document owner not found');
-        while (body.firstChild)
-            body.removeChild(body.firstChild);
-        for (const child of nodeListToArray(newBodyElement.childNodes)) {
-            body.appendChild(doc.importNode(child, true));
-        }
-        const outXml = new XMLSerializer().serializeToString(dom);
-        zip.file('word/document.xml', outXml);
-        const outBuf = zip.generate({ type: 'nodebuffer' });
-        await fs.writeFile(outputPath, outBuf);
-    }
-    finally {
-        try {
-            await fs.unlink(tempDocxPath);
-        }
-        catch { /* ignore */ }
-        try {
-            await fs.unlink(tempXmlPath);
-        }
-        catch { /* ignore */ }
-    }
-}
-// ═══════════════════════════════════════════════════════════════════════
-// writeDocx — create minimal DOCX from plain text
-// ═══════════════════════════════════════════════════════════════════════
-/**
- * Create a brand-new minimal DOCX from a plain-text string.
- * Double-newlines are treated as paragraph separators.
- */
-export async function writeDocx(outputPath, content) {
-    if (typeof content !== 'string') {
-        throw new Error('Modifications require an existing DOCX file. Use modifyDocxContent() instead.');
-    }
-    const zip = new PizZip();
-    const escaped = (s) => s.replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-    const docXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <w:body>
-${content
-        .split('\n\n')
-        .map((para) => `    <w:p>
-      <w:r>
-        <w:t>${escaped(para)}</w:t>
-      </w:r>
-    </w:p>`)
-        .join('\n')}
-  </w:body>
-</w:document>`;
-    zip.file('word/document.xml', docXml);
-    zip.file('[Content_Types].xml', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
-  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
-  <Default Extension="xml" ContentType="application/xml"/>
-  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
-</Types>`);
-    zip.folder('_rels')?.file('.rels', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
-</Relationships>`);
-    zip.folder('word')?.folder('_rels')?.file('document.xml.rels', `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
-</Relationships>`);
-    const outBuf = zip.generate({ type: 'nodebuffer' });
-    await fs.writeFile(outputPath, outBuf);
-}
-// ═══════════════════════════════════════════════════════════════════════
-// Private modification appliers (SRP: one function per modification type)
-// ═══════════════════════════════════════════════════════════════════════
-function applyReplace(body, mod) {
-    if (mod.findText === undefined)
-        return;
-    const target = mod.findText.trim();
-    for (const child of nodeListToArray(body.childNodes)) {
-        if (child.nodeType !== 1 || child.nodeName !== 'w:p')
-            continue;
-        if (getParagraphText(child).trim() !== target)
-            continue;
-        if (mod.replaceText !== undefined) {
-            setParagraphTextMinimal(child, mod.replaceText);
-        }
-        if (mod.style) {
-            if (mod.style.color)
-                colorParagraphRuns(child, mod.style.color);
-            if (mod.style.bold !== undefined || mod.style.italic !== undefined) {
-                styleParagraphRuns(child, mod.style);
-            }
-        }
-        break; // first match only
-    }
-}
-function applyInsert(body, mod) {
-    if (mod.paragraphIndex === undefined || mod.insertText === undefined)
-        return;
-    const doc = body.ownerDocument;
-    if (!doc)
-        return;
-    const newP = doc.createElement('w:p');
-    const newR = doc.createElement('w:r');
-    const newT = doc.createElement('w:t');
-    newT.textContent = mod.insertText;
-    newR.appendChild(newT);
-    newP.appendChild(newR);
-    const paragraphs = getParagraphs(body);
-    const idx = mod.paragraphIndex < 0
-        ? paragraphs.length + mod.paragraphIndex + 1
-        : mod.paragraphIndex;
-    if (idx < 0 || idx > paragraphs.length)
-        return;
-    if (idx === paragraphs.length) {
-        body.appendChild(newP);
-    }
-    else {
-        let current = 0;
-        for (const child of nodeListToArray(body.childNodes)) {
-            if (child.nodeType !== 1 || child.nodeName !== 'w:p')
-                continue;
-            if (current === idx) {
-                body.insertBefore(newP, child);
-                break;
-            }
-            current++;
-        }
-    }
-}
-function applyDelete(body, mod) {
-    if (mod.paragraphIndex === undefined)
-        return;
-    const paragraphs = getParagraphs(body);
-    const idx = mod.paragraphIndex < 0
-        ? paragraphs.length + mod.paragraphIndex
-        : mod.paragraphIndex;
-    if (idx < 0 || idx >= paragraphs.length)
-        return;
-    let current = 0;
-    for (const child of nodeListToArray(body.childNodes)) {
-        if (child.nodeType !== 1 || child.nodeName !== 'w:p')
-            continue;
-        if (current === idx) {
-            body.removeChild(child);
-            break;
-        }
-        current++;
-    }
-}
-function applyStyle(body, mod) {
-    if (mod.paragraphIndex === undefined || !mod.style)
-        return;
-    const paragraphs = getParagraphs(body);
-    const idx = mod.paragraphIndex < 0
-        ? paragraphs.length + mod.paragraphIndex
-        : mod.paragraphIndex;
-    if (idx < 0 || idx >= paragraphs.length)
-        return;
-    let current = 0;
-    for (const child of nodeListToArray(body.childNodes)) {
-        if (child.nodeType !== 1 || child.nodeName !== 'w:p')
-            continue;
-        if (current === idx) {
-            if (mod.style.color)
-                colorParagraphRuns(child, mod.style.color);
-            if (mod.style.bold !== undefined || mod.style.italic !== undefined) {
-                styleParagraphRuns(child, mod.style);
-            }
-            break;
-        }
-        current++;
-    }
-}

package/dist/tools/docx/operations/handlers/index.d.ts

@@ -1,39 +0,0 @@
-/**
- * DOCX Operation Handlers
- *
- * Pure functions: HTML in → modified HTML out.
- * Each handler corresponds to one DocxOperation type.
- *
- * @module docx/operations/handlers
- */
-import type { DocxOperation } from '../../types.js';
-/**
- * Replace text in HTML while protecting base64 data URLs and other attribute values.
- *
- * Strategy: Temporarily extract `<img>` tags (which contain huge base64 data URLs)
- * and replace them with placeholders, perform the text replacement,
- * then restore the original `<img>` tags. This prevents the regex from
- * accidentally matching / corrupting base64 image data.
- */
-export declare function handleReplaceText(html: string, search: string, replace: string, matchCase?: boolean, global?: boolean): string;
-export declare function handleAppendMarkdown(html: string, markdown: string): string;
-export declare function handleAppendHtml(html: string, content: string): string;
-export declare function handleInsertHtml(html: string, content: string, selector?: string, position?: 'before' | 'after' | 'inside'): string;
-export declare function handleReplaceHtml(html: string, selector: string, content: string, replaceAll?: boolean): string;
-export declare function handleUpdateHtml(html: string, selector: string, content?: string, attributes?: Record<string, string>, updateAll?: boolean): string;
-/**
- * Insert a table from markdown or a rows array.
- * If a selector is given, the table is placed relative to that element;
- * otherwise it is appended to the end of the document.
- */
-export declare function handleInsertTable(html: string, markdownTable?: string, rows?: string[][], selector?: string, position?: 'before' | 'after' | 'inside'): string;
-/**
- * Insert an image into the document.
- *
- * By the time this handler runs, local file paths should already be converted
- * to base64 data URLs by `preprocessOperations()` in `operations/index.ts`.
- * html-to-docx only supports base64 data URLs and HTTP URLs.
- */
-export declare function handleInsertImage(html: string, imagePath: string, altText?: string, width?: number, height?: number, baseDir?: string, selector?: string, position?: 'before' | 'after' | 'inside'): string;
-/** Apply a single DocxOperation to HTML content, routing to the correct handler. */
-export declare function applyOperation(html: string, operation: DocxOperation, baseDir?: string): string;

package/dist/tools/docx/operations/handlers/index.js

@@ -1,152 +0,0 @@
-/**
- * DOCX Operation Handlers
- *
- * Pure functions: HTML in → modified HTML out.
- * Each handler corresponds to one DocxOperation type.
- *
- * @module docx/operations/handlers
- */
-import { DocxError, DocxErrorCode } from '../../errors.js';
-import { markdownToHtml, markdownTableToHtml, buildMarkdownTableFromRows, } from '../../converters/markdown-to-html.js';
-import { appendHtml, insertHtml, replaceHtml, updateHtml } from '../html-manipulator.js';
-import { escapeHtmlAttribute, escapeRegExp } from '../../utils/escaping.js';
-import { isUrl, isDataUrl, resolveImagePath } from '../../utils/paths.js';
-import { validateImageDimensions } from '../../validators.js';
-// ─── Text Operations ─────────────────────────────────────────────────────────
-/**
- * Replace text in HTML while protecting base64 data URLs and other attribute values.
- *
- * Strategy: Temporarily extract `<img>` tags (which contain huge base64 data URLs)
- * and replace them with placeholders, perform the text replacement,
- * then restore the original `<img>` tags. This prevents the regex from
- * accidentally matching / corrupting base64 image data.
- */
-export function handleReplaceText(html, search, replace, matchCase = false, global = true) {
-    if (!search?.trim())
-        return html;
-    // Extract and protect all <img> tags from text replacement
-    const imgPlaceholders = [];
-    const protectedHtml = html.replace(/<img\s[^>]*>/gi, (match) => {
-        imgPlaceholders.push(match);
-        return `\x00IMG_PLACEHOLDER_${imgPlaceholders.length - 1}\x00`;
-    });
-    // Perform the text replacement on the protected HTML
-    const flags = matchCase ? (global ? 'g' : '') : global ? 'gi' : 'i';
-    let result = protectedHtml.replace(new RegExp(escapeRegExp(search), flags), replace);
-    // Restore the original <img> tags
-    for (let i = 0; i < imgPlaceholders.length; i++) {
-        result = result.replace(`\x00IMG_PLACEHOLDER_${i}\x00`, imgPlaceholders[i]);
-    }
-    return result;
-}
-// ─── HTML / Markdown Append & Insert ─────────────────────────────────────────
-export function handleAppendMarkdown(html, markdown) {
-    if (!markdown?.trim())
-        return html;
-    const converted = markdownToHtml(markdown);
-    return converted ? appendHtml(html, converted) : html;
-}
-export function handleAppendHtml(html, content) {
-    return appendHtml(html, content);
-}
-export function handleInsertHtml(html, content, selector, position = 'after') {
-    return insertHtml(html, content, selector, position);
-}
-export function handleReplaceHtml(html, selector, content, replaceAll = false) {
-    return replaceHtml(html, selector, content, replaceAll);
-}
-export function handleUpdateHtml(html, selector, content, attributes, updateAll = false) {
-    return updateHtml(html, selector, content, attributes, updateAll);
-}
-// ─── Table Insertion ─────────────────────────────────────────────────────────
-/**
- * Insert a table from markdown or a rows array.
- * If a selector is given, the table is placed relative to that element;
- * otherwise it is appended to the end of the document.
- */
-export function handleInsertTable(html, markdownTable, rows, selector, position = 'after') {
-    let tableHtml = '';
-    if (markdownTable?.trim()) {
-        tableHtml = markdownTableToHtml(markdownTable);
-    }
-    else if (rows?.length) {
-        const md = buildMarkdownTableFromRows(rows);
-        if (md)
-            tableHtml = markdownTableToHtml(md);
-    }
-    if (!tableHtml)
-        return html;
-    return selector?.trim()
-        ? insertHtml(html, tableHtml, selector, position)
-        : appendHtml(html, tableHtml);
-}
-// ─── Image Insertion ─────────────────────────────────────────────────────────
-/**
- * Insert an image into the document.
- *
- * By the time this handler runs, local file paths should already be converted
- * to base64 data URLs by `preprocessOperations()` in `operations/index.ts`.
- * html-to-docx only supports base64 data URLs and HTTP URLs.
- */
-export function handleInsertImage(html, imagePath, altText = '', width, height, baseDir, selector, position = 'after') {
-    if (!imagePath?.trim())
-        return html;
-    if (width !== undefined || height !== undefined)
-        validateImageDimensions(width, height);
-    const trimmedPath = imagePath.trim();
-    let imageSrc;
-    if (isDataUrl(trimmedPath) || isUrl(trimmedPath)) {
-        imageSrc = trimmedPath;
-    }
-    else {
-        // Fallback: should not normally occur after preprocessing
-        const resolved = resolveImagePath(trimmedPath, baseDir).replace(/\\/g, '/');
-        imageSrc = resolved.startsWith('/') ? `file://${resolved}` : `file:///${resolved}`;
-    }
-    // Build img attributes
-    const attrs = [`src="${escapeHtmlAttribute(imageSrc)}"`];
-    if (altText?.trim())
-        attrs.push(`alt="${escapeHtmlAttribute(altText.trim())}"`);
-    // Add dimensions as both attributes and inline style (for compatibility)
-    const styles = [];
-    if (width && width > 0) {
-        attrs.push(`width="${width}"`);
-        styles.push(`width:${width}px`);
-    }
-    if (height && height > 0) {
-        attrs.push(`height="${height}"`);
-        styles.push(`height:${height}px`);
-    }
-    if (styles.length > 0)
-        attrs.push(`style="${styles.join('; ')}"`);
-    const imgTag = `<p><img ${attrs.join(' ')} /></p>`;
-    return selector?.trim()
-        ? insertHtml(html, imgTag, selector, position)
-        : appendHtml(html, imgTag);
-}
-// ─── Operation Router ────────────────────────────────────────────────────────
-/** Apply a single DocxOperation to HTML content, routing to the correct handler. */
-export function applyOperation(html, operation, baseDir) {
-    switch (operation.type) {
-        case 'replaceText':
-            return handleReplaceText(html, operation.search, operation.replace, operation.matchCase ?? false, operation.global ?? true);
-        case 'appendMarkdown':
-            return handleAppendMarkdown(html, operation.markdown);
-        case 'appendHtml':
-            return handleAppendHtml(html, operation.html);
-        case 'insertHtml':
-            return handleInsertHtml(html, operation.html, operation.selector, operation.position ?? 'after');
-        case 'replaceHtml':
-            return handleReplaceHtml(html, operation.selector, operation.html, operation.replaceAll ?? false);
-        case 'updateHtml':
-            return handleUpdateHtml(html, operation.selector, operation.html, operation.attributes, operation.updateAll ?? false);
-        case 'insertTable':
-            return handleInsertTable(html, operation.markdownTable, operation.rows, operation.selector, operation.position ?? 'after');
-        case 'insertImage':
-            return handleInsertImage(html, operation.imagePath, operation.altText, operation.width, operation.height, baseDir, operation.selector, operation.position ?? 'after');
-        default: {
-            const unknownOp = operation;
-            throw new DocxError(`Unknown operation type: ${unknownOp.type}`, DocxErrorCode.UNKNOWN_OPERATION, { operation: unknownOp });
-        }
-    }
-}

package/dist/tools/docx/operations/html-manipulator.d.ts

@@ -1,24 +0,0 @@
-/**
- * HTML DOM Manipulation
- *
- * DOM-based insert / append / replace / update for HTML content.
- * Uses @xmldom/xmldom as the parser (not a browser DOMParser).
- *
- * IMPORTANT: All public functions use `Base64Guard` to protect base64 data URLs
- * from corruption during xmldom parse/serialize cycles. Without this, images
- * (which are embedded as long `data:image/...;base64,...` strings in `src` attributes)
- * can be lost or mangled by the XML serializer.
- *
- * @module docx/operations/html-manipulator
- */
-/** Append HTML content to the end of the document body. */
-export declare function appendHtml(html: string, content: string): string;
-/**
- * Insert HTML content at a specific position relative to a selector target.
- * If no selector is given, appends to the root element.
- */
-export declare function insertHtml(html: string, content: string, selector?: string, position?: 'before' | 'after' | 'inside'): string;
-/** Replace matched elements with new HTML content. */
-export declare function replaceHtml(html: string, selector: string, content: string, replaceAll?: boolean): string;
-/** Update matched elements' content and/or attributes. */
-export declare function updateHtml(html: string, selector: string, content?: string, attributes?: Record<string, string>, updateAll?: boolean): string;