@gobi-starweaver/ws-cli 0.3.1

package/mcp/servers/doc-toolchain-server.js

@@ -0,0 +1,1516 @@
+#!/usr/bin/env node
+import {
+  killProcessTree
+} from "../../chunks/chunk-S7EGXUII.js";
+import {
+  __name,
+  init_esbuild_shims
+} from "../../chunks/chunk-BUBNMVFA.js";
+
+// packages/core/src/mcp/servers/doc-toolchain-server.ts
+init_esbuild_shims();
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// packages/core/src/mcp/servers/doc-toolchain/ooxml.ts
+init_esbuild_shims();
+
+// packages/core/src/mcp/servers/doc-toolchain/zip.ts
+init_esbuild_shims();
+import { deflateRawSync, inflateRawSync } from "node:zlib";
+var EOCD_SIGNATURE = 101010256;
+var CENTRAL_SIGNATURE = 33639248;
+var LOCAL_SIGNATURE = 67324752;
+var ZIP64_EOCD_SIGNATURE = 101075792;
+var METHOD_STORED = 0;
+var METHOD_DEFLATE = 8;
+var FLAG_UTF8 = 1 << 11;
+var ZipFormatError = class extends Error {
+  static {
+    __name(this, "ZipFormatError");
+  }
+};
+function findEocdOffset(buffer) {
+  const earliest = Math.max(0, buffer.length - 22 - 65535);
+  for (let offset = buffer.length - 22; offset >= earliest; offset -= 1) {
+    if (buffer.readUInt32LE(offset) === EOCD_SIGNATURE) {
+      return offset;
+    }
+  }
+  throw new ZipFormatError("not-a-zip:\u672A\u627E\u5230 EOCD \u8BB0\u5F55");
+}
+__name(findEocdOffset, "findEocdOffset");
+function readZipEntries(buffer) {
+  const eocdOffset = findEocdOffset(buffer);
+  if (eocdOffset >= 4 && buffer.readUInt32LE(eocdOffset - 20) === ZIP64_EOCD_SIGNATURE) {
+    throw new ZipFormatError("zip64-unsupported:ZIP64 \u6863\u6848\u6682\u4E0D\u652F\u6301");
+  }
+  const entryCount = buffer.readUInt16LE(eocdOffset + 10);
+  let centralOffset = buffer.readUInt32LE(eocdOffset + 16);
+  const entries = [];
+  for (let index = 0; index < entryCount; index += 1) {
+    if (centralOffset + 46 > buffer.length || buffer.readUInt32LE(centralOffset) !== CENTRAL_SIGNATURE) {
+      throw new ZipFormatError(`not-a-zip:\u4E2D\u592E\u76EE\u5F55\u7B2C ${index} \u6761\u7B7E\u540D\u9519`);
+    }
+    const method = buffer.readUInt16LE(centralOffset + 10);
+    const compressedSize = buffer.readUInt32LE(centralOffset + 20);
+    const uncompressedSize = buffer.readUInt32LE(centralOffset + 24);
+    const nameLength = buffer.readUInt16LE(centralOffset + 28);
+    const extraLength = buffer.readUInt16LE(centralOffset + 30);
+    const commentLength = buffer.readUInt16LE(centralOffset + 32);
+    const localOffset = buffer.readUInt32LE(centralOffset + 42);
+    const name = buffer.subarray(centralOffset + 46, centralOffset + 46 + nameLength).toString("utf8");
+    if (compressedSize === 4294967295 || uncompressedSize === 4294967295 || localOffset === 4294967295) {
+      throw new ZipFormatError("zip64-unsupported:ZIP64 \u6863\u6848\u6682\u4E0D\u652F\u6301");
+    }
+    if (localOffset + 30 > buffer.length || buffer.readUInt32LE(localOffset) !== LOCAL_SIGNATURE) {
+      throw new ZipFormatError(`not-a-zip:\u6761\u76EE ${name} \u672C\u5730\u5934\u7B7E\u540D\u9519`);
+    }
+    const localNameLength = buffer.readUInt16LE(localOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + localNameLength + localExtraLength;
+    if (dataStart + compressedSize > buffer.length) {
+      throw new ZipFormatError(`not-a-zip:\u6761\u76EE ${name} \u6570\u636E\u8D8A\u754C`);
+    }
+    entries.push({
+      name,
+      method,
+      compressed: buffer.subarray(dataStart, dataStart + compressedSize),
+      compressedSize,
+      uncompressedSize
+    });
+    centralOffset += 46 + nameLength + extraLength + commentLength;
+  }
+  return entries;
+}
+__name(readZipEntries, "readZipEntries");
+function inflateZipEntry(entry) {
+  if (entry.method === METHOD_STORED) {
+    return Buffer.from(entry.compressed);
+  }
+  if (entry.method === METHOD_DEFLATE) {
+    const inflated = inflateRawSync(entry.compressed);
+    if (inflated.length !== entry.uncompressedSize) {
+      throw new ZipFormatError(`bad-inflate:\u6761\u76EE ${entry.name} \u89E3\u538B\u957F\u5EA6\u4E0E\u76EE\u5F55\u4E0D\u7B26`);
+    }
+    return inflated;
+  }
+  throw new ZipFormatError(`method-unsupported:\u6761\u76EE ${entry.name} \u538B\u7F29\u65B9\u6CD5 ${entry.method} \u4E0D\u652F\u6301`);
+}
+__name(inflateZipEntry, "inflateZipEntry");
+function readZipText(entries, name) {
+  const entry = entries.find((candidate) => candidate.name === name);
+  if (!entry) return null;
+  return inflateZipEntry(entry).toString("utf8");
+}
+__name(readZipText, "readZipText");
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(data) {
+  let crc = 4294967295;
+  for (let index = 0; index < data.length; index += 1) {
+    crc = CRC_TABLE[(crc ^ data[index]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+__name(crc32, "crc32");
+function writeZip(inputs) {
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const input of inputs) {
+    const nameBytes = Buffer.from(input.name, "utf8");
+    const compressed = deflateRawSync(input.data, { level: 9 });
+    const crc = crc32(input.data);
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(LOCAL_SIGNATURE, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(FLAG_UTF8, 6);
+    local.writeUInt16LE(METHOD_DEFLATE, 8);
+    local.writeUInt16LE(0, 10);
+    local.writeUInt16LE(33, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(compressed.length, 18);
+    local.writeUInt32LE(input.data.length, 22);
+    local.writeUInt16LE(nameBytes.length, 26);
+    local.writeUInt16LE(0, 28);
+    chunks.push(local, nameBytes, compressed);
+    const centralHeader = Buffer.alloc(46);
+    centralHeader.writeUInt32LE(CENTRAL_SIGNATURE, 0);
+    centralHeader.writeUInt16LE(20, 4);
+    centralHeader.writeUInt16LE(20, 6);
+    centralHeader.writeUInt16LE(FLAG_UTF8, 8);
+    centralHeader.writeUInt16LE(METHOD_DEFLATE, 10);
+    centralHeader.writeUInt16LE(0, 12);
+    centralHeader.writeUInt16LE(33, 14);
+    centralHeader.writeUInt32LE(crc, 16);
+    centralHeader.writeUInt32LE(compressed.length, 20);
+    centralHeader.writeUInt32LE(input.data.length, 24);
+    centralHeader.writeUInt16LE(nameBytes.length, 28);
+    centralHeader.writeUInt16LE(0, 30);
+    centralHeader.writeUInt16LE(0, 32);
+    centralHeader.writeUInt16LE(0, 34);
+    centralHeader.writeUInt16LE(0, 36);
+    centralHeader.writeUInt32LE(0, 38);
+    centralHeader.writeUInt32LE(offset, 42);
+    central.push(centralHeader, nameBytes);
+    offset += 30 + nameBytes.length + compressed.length;
+  }
+  const centralBuffer = Buffer.concat(central);
+  const eocd = Buffer.alloc(22);
+  eocd.writeUInt32LE(EOCD_SIGNATURE, 0);
+  eocd.writeUInt16LE(0, 4);
+  eocd.writeUInt16LE(0, 6);
+  eocd.writeUInt16LE(inputs.length, 8);
+  eocd.writeUInt16LE(inputs.length, 10);
+  eocd.writeUInt32LE(centralBuffer.length, 12);
+  eocd.writeUInt32LE(offset, 16);
+  eocd.writeUInt16LE(0, 20);
+  return Buffer.concat([...chunks, centralBuffer, eocd]);
+}
+__name(writeZip, "writeZip");
+
+// packages/core/src/mcp/servers/doc-toolchain/ooxml.ts
+var XML_DECLARATION = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`;
+var OoxmlFormatError = class extends Error {
+  static {
+    __name(this, "OoxmlFormatError");
+  }
+};
+function localName(name) {
+  const colon = name.indexOf(":");
+  return colon >= 0 ? name.slice(colon + 1) : name;
+}
+__name(localName, "localName");
+function parseAttributes(source) {
+  const attrs = {};
+  const pattern = /([A-Za-z_][\w:.-]*)\s*=\s*"([^"]*)"/g;
+  let match;
+  while ((match = pattern.exec(source)) !== null) {
+    attrs[match[1]] = unescapeXml(match[2]);
+  }
+  return attrs;
+}
+__name(parseAttributes, "parseAttributes");
+function unescapeXml(value) {
+  return value.replace(/&(amp|lt|gt|quot|apos|#x[0-9A-Fa-f]+|#\d+);/g, (whole, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default: {
+        const code = entity.startsWith("#x") ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+        return Number.isFinite(code) ? String.fromCodePoint(code) : whole;
+      }
+    }
+  });
+}
+__name(unescapeXml, "unescapeXml");
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+__name(escapeXml, "escapeXml");
+function tokenizeXml(xml) {
+  const tokens = [];
+  let cursor = 0;
+  const length = xml.length;
+  while (cursor < length) {
+    const lt = xml.indexOf("<", cursor);
+    if (lt < 0) {
+      tokens.push({ type: "text", text: unescapeXml(xml.slice(cursor)), start: cursor, end: length });
+      break;
+    }
+    if (lt > cursor) {
+      tokens.push({ type: "text", text: unescapeXml(xml.slice(cursor, lt)), start: cursor, end: lt });
+    }
+    if (xml.startsWith("<?", lt)) {
+      const end = xml.indexOf("?>", lt + 2);
+      cursor = end < 0 ? length : end + 2;
+      continue;
+    }
+    if (xml.startsWith("<!--", lt)) {
+      const end = xml.indexOf("-->", lt + 4);
+      cursor = end < 0 ? length : end + 3;
+      continue;
+    }
+    if (xml.startsWith("<![CDATA[", lt)) {
+      const end = xml.indexOf("]]>", lt + 9);
+      const textEnd = end < 0 ? length : end;
+      tokens.push({ type: "text", text: xml.slice(lt + 9, textEnd), start: lt, end: end < 0 ? length : end + 3 });
+      cursor = end < 0 ? length : end + 3;
+      continue;
+    }
+    if (xml.startsWith("<!", lt)) {
+      const end = xml.indexOf(">", lt + 2);
+      cursor = end < 0 ? length : end + 1;
+      continue;
+    }
+    if (xml.startsWith("</", lt)) {
+      const end = xml.indexOf(">", lt + 2);
+      if (end < 0) throw new OoxmlFormatError("bad-xml:\u95ED\u5408\u6807\u7B7E\u672A\u6536\u5C3E");
+      const name2 = xml.slice(lt + 2, end).trim();
+      tokens.push({ type: "close", name: name2, start: lt, end: end + 1 });
+      cursor = end + 1;
+      continue;
+    }
+    let scan = lt + 1;
+    let inQuote = false;
+    while (scan < length) {
+      const ch = xml[scan];
+      if (ch === '"') inQuote = !inQuote;
+      else if (ch === ">" && !inQuote) break;
+      scan += 1;
+    }
+    if (scan >= length) throw new OoxmlFormatError("bad-xml:\u5F00\u653E\u6807\u7B7E\u672A\u6536\u5C3E");
+    const inner = xml.slice(lt + 1, scan);
+    const selfClosing = /\/\s*$/.test(inner);
+    const body = selfClosing ? inner.replace(/\/\s*$/, "") : inner;
+    const nameMatch = /^([^\s]+)/.exec(body.trim());
+    if (!nameMatch) throw new OoxmlFormatError("bad-xml:\u6807\u7B7E\u540D\u4E3A\u7A7A");
+    const name = nameMatch[1];
+    const attrs = parseAttributes(body.slice(body.indexOf(name) + name.length));
+    tokens.push({ type: "open", name, attrs, selfClosing, start: lt, end: scan + 1 });
+    cursor = scan + 1;
+  }
+  return tokens;
+}
+__name(tokenizeXml, "tokenizeXml");
+function subtreeEndIndex(tokens, index) {
+  const token = tokens[index];
+  if (token.selfClosing) return index;
+  const name = token.name;
+  let depth = 1;
+  for (let cursor = index + 1; cursor < tokens.length; cursor += 1) {
+    const current = tokens[cursor];
+    if (current.type === "open" && !current.selfClosing && current.name === name) depth += 1;
+    else if (current.type === "close" && current.name === name) depth -= 1;
+    else if (current.type === "open" && current.selfClosing) {
+    }
+    if (depth === 0) return cursor;
+  }
+  throw new OoxmlFormatError(`bad-xml:\u6807\u7B7E ${name} \u672A\u914D\u5E73`);
+}
+__name(subtreeEndIndex, "subtreeEndIndex");
+function paragraphTextFromTokens(tokens, startIndex, endIndex) {
+  let text = "";
+  let insideText = false;
+  let delDepth = 0;
+  for (let cursor = startIndex; cursor <= endIndex; cursor += 1) {
+    const token = tokens[cursor];
+    if (token.type === "open") {
+      const local = localName(token.name);
+      if (local === "del") {
+        if (!token.selfClosing) delDepth += 1;
+      } else if (local === "t" && delDepth === 0) {
+        if (!token.selfClosing) insideText = true;
+      } else if ((local === "tab" || local === "br" || local === "cr") && delDepth === 0) {
+        text += local === "tab" ? "	" : "\n";
+      } else if (local === "noBreakHyphen" && delDepth === 0) {
+        text += "-";
+      }
+    } else if (token.type === "close") {
+      const local = localName(token.name);
+      if (local === "del" && delDepth > 0) delDepth -= 1;
+      else if (local === "t") insideText = false;
+    } else if (insideText && delDepth === 0) {
+      text += token.text;
+    }
+  }
+  return text;
+}
+__name(paragraphTextFromTokens, "paragraphTextFromTokens");
+function paragraphStyleFromTokens(tokens, startIndex, endIndex) {
+  for (let cursor = startIndex; cursor <= endIndex; cursor += 1) {
+    const token = tokens[cursor];
+    if (token.type === "open" && localName(token.name) === "pStyle") {
+      const value = token.attrs["w:val"] ?? token.attrs.val;
+      if (value) return value;
+    }
+  }
+  return null;
+}
+__name(paragraphStyleFromTokens, "paragraphStyleFromTokens");
+function walkBody(tokens) {
+  const bodyOpenIndex = tokens.findIndex((token) => token.type === "open" && localName(token.name) === "body");
+  if (bodyOpenIndex < 0) throw new OoxmlFormatError("bad-docx:\u672A\u627E\u5230 w:body");
+  const bodyEndIndex = subtreeEndIndex(tokens, bodyOpenIndex);
+  const blocks = [];
+  const paragraphSpans = [];
+  let sectPrSpan = null;
+  let tableCount = 0;
+  let cursor = bodyOpenIndex + 1;
+  while (cursor < bodyEndIndex) {
+    const token = tokens[cursor];
+    if (token.type !== "open") {
+      cursor += 1;
+      continue;
+    }
+    const local = localName(token.name);
+    if (local === "p") {
+      const endIndex = token.selfClosing ? cursor : subtreeEndIndex(tokens, cursor);
+      const start = token.start;
+      const end = tokens[endIndex].end;
+      const text = token.selfClosing ? "" : paragraphTextFromTokens(tokens, cursor + 1, endIndex - 1);
+      const style = token.selfClosing ? null : paragraphStyleFromTokens(tokens, cursor + 1, endIndex - 1);
+      paragraphSpans.push({ start, end });
+      blocks.push({ type: "paragraph", paragraphIndex: paragraphSpans.length - 1, style, text });
+      cursor = endIndex + 1;
+      continue;
+    }
+    if (local === "tbl") {
+      const endIndex = subtreeEndIndex(tokens, cursor);
+      const rows = [];
+      let rowDepth = 0;
+      let currentRow = null;
+      let currentCell = null;
+      let cellParagraphStart = -1;
+      for (let inner = cursor + 1; inner < endIndex; inner += 1) {
+        const innerToken = tokens[inner];
+        if (innerToken.type === "open") {
+          const innerLocal = localName(innerToken.name);
+          if (innerLocal === "tr") {
+            if (innerToken.selfClosing) {
+              if (rowDepth === 0) rows.push([]);
+            } else {
+              if (rowDepth === 0) currentRow = [];
+              rowDepth += 1;
+            }
+          } else if (innerLocal === "tc" && rowDepth === 1 && currentRow) {
+            if (innerToken.selfClosing) currentRow.push([]);
+            else currentCell = [];
+          } else if (innerLocal === "p" && currentCell) {
+            if (innerToken.selfClosing) currentCell.push("");
+            else cellParagraphStart = inner;
+          }
+        } else if (innerToken.type === "close") {
+          const innerLocal = localName(innerToken.name);
+          if (innerLocal === "p" && currentCell && cellParagraphStart >= 0) {
+            currentCell.push(paragraphTextFromTokens(tokens, cellParagraphStart + 1, inner - 1));
+            cellParagraphStart = -1;
+          } else if (innerLocal === "tc" && rowDepth === 1 && currentRow && currentCell) {
+            currentRow.push(currentCell);
+            currentCell = null;
+          } else if (innerLocal === "tr") {
+            if (rowDepth === 1 && currentRow) {
+              rows.push(currentRow.map((cell) => cell.join("\n")));
+              currentRow = null;
+            }
+            rowDepth -= 1;
+          }
+        }
+      }
+      blocks.push({ type: "table", tableIndex: tableCount, rows });
+      tableCount += 1;
+      cursor = endIndex + 1;
+      continue;
+    }
+    if (local === "sectPr") {
+      const endIndex = token.selfClosing ? cursor : subtreeEndIndex(tokens, cursor);
+      sectPrSpan = { start: token.start, end: tokens[endIndex].end };
+      cursor = endIndex + 1;
+      continue;
+    }
+    cursor = token.selfClosing ? cursor + 1 : subtreeEndIndex(tokens, cursor) + 1;
+  }
+  return {
+    blocks,
+    paragraphSpans,
+    sectPrSpan,
+    bodyCloseStart: tokens[bodyEndIndex].start
+  };
+}
+__name(walkBody, "walkBody");
+function notesFromXml(xml, elementLocal) {
+  if (!xml) return [];
+  const tokens = tokenizeXml(xml);
+  const notes = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.type !== "open" || localName(token.name) !== elementLocal || token.selfClosing) continue;
+    const id = token.attrs["w:id"] ?? token.attrs.id ?? "";
+    if (id === "-1" || id === "0") continue;
+    const endIndex = subtreeEndIndex(tokens, index);
+    notes.push({ id, text: paragraphTextFromTokens(tokens, index + 1, endIndex - 1) });
+    index = endIndex;
+  }
+  return notes;
+}
+__name(notesFromXml, "notesFromXml");
+function readDocx(buffer, options = {}) {
+  const entries = readZipEntries(buffer);
+  const documentXml = readZipText(entries, "word/document.xml");
+  if (documentXml === null) throw new OoxmlFormatError("bad-docx:\u7F3A word/document.xml");
+  const walk = walkBody(tokenizeXml(documentXml));
+  const textParts = [];
+  let characters = 0;
+  for (const block of walk.blocks) {
+    if (block.type === "paragraph") {
+      textParts.push(block.text);
+      characters += block.text.replace(/\s/g, "").length;
+    } else {
+      textParts.push(block.rows.map((row) => row.join(" | ")).join("\n"));
+    }
+  }
+  const result = {
+    blocks: walk.blocks,
+    paragraphCount: walk.paragraphSpans.length,
+    tableCount: walk.blocks.filter((block) => block.type === "table").length,
+    text: textParts.join("\n"),
+    stats: {
+      characters,
+      paragraphs: walk.paragraphSpans.length,
+      tables: walk.blocks.filter((block) => block.type === "table").length
+    }
+  };
+  if (options.includeNotes) {
+    result.notes = {
+      footnotes: notesFromXml(readZipText(entries, "word/footnotes.xml"), "footnote"),
+      endnotes: notesFromXml(readZipText(entries, "word/endnotes.xml"), "endnote"),
+      comments: notesFromXml(readZipText(entries, "word/comments.xml"), "comment")
+    };
+  }
+  return result;
+}
+__name(readDocx, "readDocx");
+var CONTENT_TYPES_XML = `${XML_DECLARATION}
+<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"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/><Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/></Types>`;
+var ROOT_RELS_XML = `${XML_DECLARATION}
+<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>`;
+var DOCUMENT_RELS_XML = `${XML_DECLARATION}
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/></Relationships>`;
+var STYLES_XML = `${XML_DECLARATION}
+<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="Times New Roman" w:eastAsia="\u5B8B\u4F53" w:hAnsi="Times New Roman" w:cs="Times New Roman"/><w:sz w:val="24"/><w:szCs w:val="24"/></w:rPr></w:rPrDefault></w:docDefaults><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/><w:qFormat/></w:style><w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:qFormat/><w:pPr><w:keepNext/><w:spacing w:before="240" w:after="120"/><w:outlineLvl w:val="0"/></w:pPr><w:rPr><w:b/><w:sz w:val="32"/><w:szCs w:val="32"/></w:rPr></w:style><w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:qFormat/><w:pPr><w:keepNext/><w:spacing w:before="200" w:after="100"/><w:outlineLvl w:val="1"/></w:pPr><w:rPr><w:b/><w:sz w:val="28"/><w:szCs w:val="28"/></w:rPr></w:style><w:style w:type="paragraph" w:styleId="Heading3"><w:name w:val="heading 3"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:qFormat/><w:pPr><w:keepNext/><w:spacing w:before="160" w:after="80"/><w:outlineLvl w:val="2"/></w:pPr><w:rPr><w:b/><w:sz w:val="24"/><w:szCs w:val="24"/></w:rPr></w:style><w:style w:type="paragraph" w:styleId="ListParagraph"><w:name w:val="List Paragraph"/><w:basedOn w:val="Normal"/><w:pPr><w:ind w:left="720"/></w:pPr></w:style></w:styles>`;
+var NUMBERING_XML = `${XML_DECLARATION}
+<w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:abstractNum w:abstractNumId="0"><w:lvl w:ilvl="0"><w:start w:val="1"/><w:numFmt w:val="bullet"/><w:lvlText w:val="\xB7"/><w:lvlJc w:val="left"/><w:pPr><w:ind w:left="720" w:hanging="360"/></w:pPr></w:lvl></w:abstractNum><w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num></w:numbering>`;
+var SECT_PR_XML = `<w:sectPr><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="851" w:footer="992" w:gutter="0"/></w:sectPr>`;
+function runXmlForText(text) {
+  const lines = text.split("\n");
+  const segments = lines.map((line) => `<w:t xml:space="preserve">${escapeXml(line)}</w:t>`);
+  return `<w:r>${segments.join("<w:br/>")}</w:r>`;
+}
+__name(runXmlForText, "runXmlForText");
+function paragraphXml(text, style) {
+  const pPr = style ? `<w:pPr><w:pStyle w:val="${escapeXml(style)}"/></w:pPr>` : "";
+  if (!text) {
+    return `<w:p>${pPr}</w:p>`;
+  }
+  return `<w:p>${pPr}${runXmlForText(text)}</w:p>`;
+}
+__name(paragraphXml, "paragraphXml");
+function listItemXml(text) {
+  return `<w:p><w:pPr><w:pStyle w:val="ListParagraph"/><w:numPr><w:ilvl w:val="0"/><w:numId w:val="1"/></w:numPr></w:pPr>${runXmlForText(text)}</w:p>`;
+}
+__name(listItemXml, "listItemXml");
+function isCjk(codePoint) {
+  return codePoint >= 19968 && codePoint <= 40959 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 12288 && codePoint <= 12351 || codePoint >= 65280 && codePoint <= 65519;
+}
+__name(isCjk, "isCjk");
+function markdownToBodyXml(markdown) {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  const parts = [];
+  let paragraphBuffer = [];
+  const flushParagraph = /* @__PURE__ */ __name(() => {
+    if (paragraphBuffer.length === 0) return;
+    let merged = paragraphBuffer[0];
+    for (let index = 1; index < paragraphBuffer.length; index += 1) {
+      const previous = merged[merged.length - 1] ?? "";
+      const next = paragraphBuffer[index][0] ?? "";
+      const glue = isCjk(previous.codePointAt(0) ?? 0) || isCjk(next.codePointAt(0) ?? 0) ? "" : " ";
+      merged += glue + paragraphBuffer[index];
+    }
+    parts.push(paragraphXml(merged));
+    paragraphBuffer = [];
+  }, "flushParagraph");
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const heading = /^(#{1,3})\s+(.*)$/.exec(line);
+    const listItem = /^[-•]\s+(.*)$/.exec(line);
+    if (heading) {
+      flushParagraph();
+      parts.push(paragraphXml(heading[2], `Heading${heading[1].length}`));
+    } else if (listItem) {
+      flushParagraph();
+      parts.push(listItemXml(listItem[1]));
+    } else if (line.trim() === "") {
+      flushParagraph();
+    } else {
+      paragraphBuffer.push(line.trim());
+    }
+  }
+  flushParagraph();
+  return parts.join("");
+}
+__name(markdownToBodyXml, "markdownToBodyXml");
+function buildDocx(markdown) {
+  const documentXml = `${XML_DECLARATION}
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${markdownToBodyXml(markdown)}${SECT_PR_XML}</w:body></w:document>`;
+  return writeZip([
+    { name: "[Content_Types].xml", data: Buffer.from(CONTENT_TYPES_XML, "utf8") },
+    { name: "_rels/.rels", data: Buffer.from(ROOT_RELS_XML, "utf8") },
+    { name: "word/_rels/document.xml.rels", data: Buffer.from(DOCUMENT_RELS_XML, "utf8") },
+    { name: "word/document.xml", data: Buffer.from(documentXml, "utf8") },
+    { name: "word/styles.xml", data: Buffer.from(STYLES_XML, "utf8") },
+    { name: "word/numbering.xml", data: Buffer.from(NUMBERING_XML, "utf8") }
+  ]);
+}
+__name(buildDocx, "buildDocx");
+function editDocx(buffer, ops) {
+  if (!Array.isArray(ops) || ops.length === 0) {
+    throw new OoxmlFormatError("invalid-ops:ops \u4E3A\u7A7A");
+  }
+  const entries = readZipEntries(buffer);
+  const documentEntry = entries.find((entry) => entry.name === "word/document.xml");
+  if (!documentEntry) throw new OoxmlFormatError("bad-docx:\u7F3A word/document.xml");
+  const documentXml = inflateZipEntry(documentEntry).toString("utf8");
+  const tokens = tokenizeXml(documentXml);
+  const walk = walkBody(tokens);
+  const replacements = [];
+  const insertions = [];
+  const paragraphXmlAt = /* @__PURE__ */ __name((index) => {
+    const span = walk.paragraphSpans[index];
+    if (!span) {
+      throw new OoxmlFormatError(`invalid-ops:\u6BB5\u843D\u7F16\u53F7 ${index} \u8D8A\u754C\uFF08\u5171 ${walk.paragraphSpans.length} \u6BB5\uFF09`);
+    }
+    return span;
+  }, "paragraphXmlAt");
+  const extractPPr = /* @__PURE__ */ __name((start, end) => {
+    const slice = documentXml.slice(start, end);
+    const pPrMatch = /<w:pPr>[\s\S]*?<\/w:pPr>/.exec(slice);
+    return pPrMatch ? pPrMatch[0] : "";
+  }, "extractPPr");
+  for (const op of ops) {
+    if (op.op === "replace_paragraph_text") {
+      const span = paragraphXmlAt(op.index);
+      if (typeof op.text !== "string") throw new OoxmlFormatError("invalid-ops:replace_paragraph_text \u7F3A text");
+      const pPr = extractPPr(span.start, span.end);
+      replacements.push({
+        start: span.start,
+        end: span.end,
+        xml: `<w:p>${pPr}${op.text ? runXmlForText(op.text) : ""}</w:p>`
+      });
+    } else if (op.op === "delete_paragraph") {
+      const span = paragraphXmlAt(op.index);
+      replacements.push({ start: span.start, end: span.end, xml: "" });
+    } else if (op.op === "insert_paragraph") {
+      const span = paragraphXmlAt(op.index);
+      if (typeof op.text !== "string") throw new OoxmlFormatError("invalid-ops:insert_paragraph \u7F3A text");
+      const xml = paragraphXml(op.text, op.style ?? null);
+      if (op.position === "before") insertions.push({ at: span.start, xml });
+      else insertions.push({ at: span.end, xml });
+    } else if (op.op === "append_paragraph") {
+      if (typeof op.text !== "string") throw new OoxmlFormatError("invalid-ops:append_paragraph \u7F3A text");
+      const at = walk.sectPrSpan ? walk.sectPrSpan.start : walk.bodyCloseStart;
+      insertions.push({ at, xml: paragraphXml(op.text, op.style ?? null) });
+    } else {
+      throw new OoxmlFormatError(`invalid-ops:\u672A\u77E5\u64CD\u4F5C ${op.op}`);
+    }
+  }
+  const touchedSpans = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    if (op.op === "replace_paragraph_text" || op.op === "delete_paragraph") {
+      if (touchedSpans.has(op.index)) {
+        throw new OoxmlFormatError(`invalid-ops:\u6BB5\u843D ${op.index} \u88AB replace/delete \u91CD\u590D\u951A\u5B9A\uFF08\u51B2\u7A81\uFF09`);
+      }
+      touchedSpans.add(op.index);
+    }
+  }
+  const edits = [
+    ...replacements.map((entry, seq) => ({ start: entry.start, end: entry.end, xml: entry.xml, kind: 0, seq })),
+    ...insertions.map((entry, seq) => ({
+      start: entry.at,
+      end: entry.at,
+      xml: entry.xml,
+      kind: 1,
+      seq: replacements.length + seq
+    }))
+  ].sort((a, b) => b.start - a.start || a.kind - b.kind || b.seq - a.seq);
+  let nextXml = documentXml;
+  for (const edit of edits) {
+    nextXml = nextXml.slice(0, edit.start) + edit.xml + nextXml.slice(edit.end);
+  }
+  const after = walkBody(tokenizeXml(nextXml));
+  const nextEntries = entries.map(
+    (entry) => entry.name === "word/document.xml" ? { name: entry.name, data: Buffer.from(nextXml, "utf8") } : { name: entry.name, data: inflateZipEntry(entry) }
+  );
+  return {
+    buffer: writeZip(nextEntries),
+    applied: ops.length,
+    paragraphCountBefore: walk.paragraphSpans.length,
+    paragraphCountAfter: after.paragraphSpans.length
+  };
+}
+__name(editDocx, "editDocx");
+
+// packages/core/src/mcp/servers/doc-toolchain/convert.ts
+init_esbuild_shims();
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+var OUTPUT_CAPTURE_LIMIT = 64 * 1024;
+function appendCapped(previous, chunk) {
+  if (previous.length >= OUTPUT_CAPTURE_LIMIT) return previous;
+  return (previous + chunk).slice(0, OUTPUT_CAPTURE_LIMIT);
+}
+__name(appendCapped, "appendCapped");
+var defaultRunProcess = /* @__PURE__ */ __name((command, args, options) => new Promise((resolve3) => {
+  let settled = false;
+  let child;
+  try {
+    child = spawn(command, args, {
+      env: options.env,
+      shell: false,
+      windowsHide: true
+    });
+  } catch (error) {
+    resolve3({
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      timedOut: false,
+      spawnError: error instanceof Error ? error.message : String(error)
+    });
+    return;
+  }
+  let stdout = "";
+  let stderr = "";
+  let timedOut = false;
+  const finish = /* @__PURE__ */ __name((exitCode) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+    resolve3({ exitCode, stdout: stdout.trim(), stderr: stderr.trim(), timedOut });
+  }, "finish");
+  const kill = /* @__PURE__ */ __name(() => {
+    if (child.pid) killProcessTree(child.pid);
+  }, "kill");
+  const timer = setTimeout(() => {
+    timedOut = true;
+    kill();
+  }, options.timeoutMs);
+  const onAbort = /* @__PURE__ */ __name(() => {
+    kill();
+  }, "onAbort");
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  child.stdout?.on("data", (chunk) => {
+    stdout = appendCapped(stdout, chunk.toString("utf8"));
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr = appendCapped(stderr, chunk.toString("utf8"));
+  });
+  child.on("error", (error) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", onAbort);
+    resolve3({ exitCode: null, stdout: "", stderr: "", timedOut, spawnError: error.message });
+  });
+  child.on("close", (code) => finish(code));
+}), "defaultRunProcess");
+var SOFFICE_ENV = "WS_SOFFICE";
+var PDFTOPPM_ENV = "WS_PDFTOPPM";
+var PYTHON_ENV = "WS_PYTHON";
+function searchPathDirs(env, platform) {
+  const raw = env.PATH ?? env.Path ?? env.path ?? "";
+  return raw.split(platform === "win32" ? ";" : ":").filter((entry) => entry.length > 0);
+}
+__name(searchPathDirs, "searchPathDirs");
+function findOnPath(names, env, platform, pathExists) {
+  for (const dir of searchPathDirs(env, platform)) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (pathExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+__name(findOnPath, "findOnPath");
+function wellKnownSofficePaths(env, platform) {
+  if (platform === "win32") {
+    const roots = [
+      env.ProgramFiles,
+      env["ProgramFiles(x86)"],
+      env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs")
+    ].filter((entry) => typeof entry === "string" && entry.length > 0);
+    return roots.map((root) => path.join(root, "LibreOffice", "program", "soffice.exe"));
+  }
+  if (platform === "darwin") {
+    return ["/Applications/LibreOffice.app/Contents/MacOS/soffice"];
+  }
+  return [
+    "/usr/bin/soffice",
+    "/usr/local/bin/soffice",
+    "/snap/bin/soffice",
+    "/usr/bin/libreoffice",
+    "/usr/local/bin/libreoffice"
+  ];
+}
+__name(wellKnownSofficePaths, "wellKnownSofficePaths");
+function wellKnownPdftoppmPaths(platform) {
+  if (platform === "win32") return [];
+  if (platform === "darwin") return ["/opt/homebrew/bin/pdftoppm", "/usr/local/bin/pdftoppm"];
+  return ["/usr/bin/pdftoppm", "/usr/local/bin/pdftoppm", "/snap/bin/pdftoppm"];
+}
+__name(wellKnownPdftoppmPaths, "wellKnownPdftoppmPaths");
+async function probeVersion(run, env, command, args, pattern) {
+  const result = await run(command, args, { env, timeoutMs: 2e4 });
+  const haystack = `${result.stdout}
+${result.stderr}`;
+  const match = pattern.exec(haystack);
+  return match ? match[0].trim() : null;
+}
+__name(probeVersion, "probeVersion");
+async function probeSofficeVersion(run, env, candidate, platform, pathExists) {
+  const version = await probeVersion(run, env, candidate, ["--version"], /LibreOffice[\s\d.]+/i);
+  if (version || platform !== "win32") return version;
+  const consoleVariant = path.join(path.dirname(candidate), "soffice.com");
+  if (consoleVariant === candidate || !pathExists(consoleVariant)) return version;
+  return probeVersion(run, env, consoleVariant, ["--version"], /LibreOffice[\s\d.]+/i);
+}
+__name(probeSofficeVersion, "probeSofficeVersion");
+async function detectSoffice(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const pathExists = deps.pathExists ?? fs.existsSync;
+  const run = deps.run ?? defaultRunProcess;
+  const probed = [];
+  const explicit = env[SOFFICE_ENV]?.trim();
+  if (explicit) {
+    const exists = pathExists(explicit);
+    const version = exists ? await probeSofficeVersion(run, env, explicit, platform, pathExists) : null;
+    return { tool: "soffice", found: true, path: explicit, source: "env", version, exists, probed: [explicit] };
+  }
+  const names = platform === "win32" ? ["soffice.exe", "soffice.com", "soffice"] : ["soffice", "libreoffice"];
+  const onPath = findOnPath(names, env, platform, pathExists);
+  if (onPath) {
+    const version = await probeSofficeVersion(run, env, onPath, platform, pathExists);
+    return { tool: "soffice", found: true, path: onPath, source: "path", version, probed: [onPath] };
+  }
+  probed.push(`PATH(${names.join("/")})`);
+  for (const candidate of wellKnownSofficePaths(env, platform)) {
+    if (pathExists(candidate)) {
+      const version = await probeSofficeVersion(run, env, candidate, platform, pathExists);
+      return {
+        tool: "soffice",
+        found: true,
+        path: candidate,
+        source: "wellknown",
+        version,
+        probed: [...probed, candidate]
+      };
+    }
+    probed.push(candidate);
+  }
+  return { tool: "soffice", found: false, path: null, source: null, version: null, probed };
+}
+__name(detectSoffice, "detectSoffice");
+async function detectPdftoppm(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const pathExists = deps.pathExists ?? fs.existsSync;
+  const run = deps.run ?? defaultRunProcess;
+  const probed = [];
+  const explicit = env[PDFTOPPM_ENV]?.trim();
+  if (explicit) {
+    const exists = pathExists(explicit);
+    const version = exists ? await probeVersion(run, env, explicit, ["-v"], /pdftoppm version [\d.]+/i) : null;
+    return { tool: "pdftoppm", found: true, path: explicit, source: "env", version, exists, probed: [explicit] };
+  }
+  const names = platform === "win32" ? ["pdftoppm.exe", "pdftoppm"] : ["pdftoppm"];
+  const onPath = findOnPath(names, env, platform, pathExists);
+  if (onPath) {
+    const version = await probeVersion(run, env, onPath, ["-v"], /pdftoppm version [\d.]+/i);
+    return { tool: "pdftoppm", found: true, path: onPath, source: "path", version, probed: [onPath] };
+  }
+  probed.push(`PATH(${names.join("/")})`);
+  for (const candidate of wellKnownPdftoppmPaths(platform)) {
+    if (pathExists(candidate)) {
+      const version = await probeVersion(run, env, candidate, ["-v"], /pdftoppm version [\d.]+/i);
+      return {
+        tool: "pdftoppm",
+        found: true,
+        path: candidate,
+        source: "wellknown",
+        version,
+        probed: [...probed, candidate]
+      };
+    }
+    probed.push(candidate);
+  }
+  return { tool: "pdftoppm", found: false, path: null, source: null, version: null, probed };
+}
+__name(detectPdftoppm, "detectPdftoppm");
+var FITZ_PROBE_SCRIPT = "import fitz,sys;print(getattr(fitz,'VersionBind','unknown'))";
+async function detectPyMuPDF(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const pathExists = deps.pathExists ?? fs.existsSync;
+  const run = deps.run ?? defaultRunProcess;
+  const probed = [];
+  const candidates = [];
+  const explicit = env[PYTHON_ENV]?.trim();
+  if (explicit) candidates.push({ command: explicit, source: "env" });
+  const pythonNames = platform === "win32" ? ["python.exe", "python3.exe"] : ["python3", "python"];
+  const onPath = findOnPath(pythonNames, env, platform, pathExists);
+  if (onPath) candidates.push({ command: onPath, source: "path" });
+  if (candidates.length === 0) {
+    probed.push(explicit ?? `PATH(${pythonNames.join("/")})`);
+    return { tool: "pymupdf", found: false, path: null, source: null, version: null, probed };
+  }
+  for (const candidate of candidates) {
+    probed.push(candidate.command);
+    const result = await run(candidate.command, ["-c", FITZ_PROBE_SCRIPT], {
+      env,
+      timeoutMs: 2e4
+    });
+    if (result.exitCode === 0 && result.stdout.trim().length > 0) {
+      return {
+        tool: "pymupdf",
+        found: true,
+        path: candidate.command,
+        source: candidate.source,
+        version: `PyMuPDF ${result.stdout.trim()}`,
+        probed
+      };
+    }
+  }
+  return { tool: "pymupdf", found: false, path: null, source: null, version: null, probed };
+}
+__name(detectPyMuPDF, "detectPyMuPDF");
+function unavailableResult(tool, message, installHint, probed) {
+  return {
+    ok: false,
+    error: { type: "tool_unavailable", tool, message, install_hint: installHint, probed }
+  };
+}
+__name(unavailableResult, "unavailableResult");
+function isInsidePath(parentDir, target) {
+  const relative2 = path.relative(parentDir, target);
+  return relative2 !== "" && !relative2.startsWith("..") && !path.isAbsolute(relative2);
+}
+__name(isInsidePath, "isInsidePath");
+function libreOfficeInstallRoot(sofficePath) {
+  return path.dirname(path.dirname(sofficePath));
+}
+__name(libreOfficeInstallRoot, "libreOfficeInstallRoot");
+async function convertDocxToPdf(inputPath, options = {}, deps = {}) {
+  const env = deps.env ?? process.env;
+  const pathExists = deps.pathExists ?? fs.existsSync;
+  const run = deps.run ?? defaultRunProcess;
+  const tmpRoot = deps.tmpRoot ?? os.tmpdir();
+  const startedAt = Date.now();
+  const resolvedInput = path.resolve(inputPath);
+  if (!pathExists(resolvedInput)) {
+    return { ok: false, error: { type: "input_not_found", message: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${resolvedInput}` } };
+  }
+  const soffice = await detectSoffice(deps);
+  if (!soffice.found || !soffice.path) {
+    return unavailableResult(
+      "libreoffice",
+      "\u672C\u673A\u672A\u627E\u5230 LibreOffice\uFF08soffice\uFF09\uFF0Cdocx\u2192PDF \u8F6C\u6362\u4E0D\u53EF\u7528\u3002",
+      "\u5B89\u88C5 LibreOffice\uFF08https://www.libreoffice.org/download/\uFF09\u540E\u91CD\u8BD5\uFF1B\u6216\u8BBE WS_SOFFICE \u6307\u5411 soffice \u53EF\u6267\u884C\u6587\u4EF6\u3002\u8BF7\u52FF\u73B0\u573A\u5199\u811A\u672C\u786C\u603C\u3002",
+      soffice.probed
+    );
+  }
+  if (soffice.exists === false) {
+    return {
+      ok: false,
+      error: {
+        type: "tool_unavailable",
+        message: `${SOFFICE_ENV} \u6307\u5411\u7684\u8DEF\u5F84\u4E0D\u5B58\u5728\uFF1A${soffice.path}`
+      }
+    };
+  }
+  const installRoot = libreOfficeInstallRoot(soffice.path);
+  if (isInsidePath(installRoot, resolvedInput)) {
+    return {
+      ok: false,
+      error: {
+        type: "libreoffice_install_dir_forbidden",
+        message: `\u8F93\u5165\u6587\u4EF6\u4F4D\u4E8E LibreOffice \u5B89\u88C5\u76EE\u5F55\u5185\uFF0C\u6309\u7EAA\u5F8B\u62D2\u7EDD\u8F6C\u6362\uFF1A${resolvedInput}`
+      }
+    };
+  }
+  const outputDir = path.resolve(options.outputDir ?? path.dirname(resolvedInput));
+  if (isInsidePath(installRoot, outputDir)) {
+    return {
+      ok: false,
+      error: {
+        type: "libreoffice_install_dir_forbidden",
+        message: `\u8F93\u51FA\u76EE\u5F55\u4F4D\u4E8E LibreOffice \u5B89\u88C5\u76EE\u5F55\u5185\uFF0C\u6309\u7EAA\u5F8B\u62D2\u7EDD\uFF1A${outputDir}`
+      }
+    };
+  }
+  fs.mkdirSync(outputDir, { recursive: true });
+  const resolvedTmpRoot = path.resolve(tmpRoot);
+  const profile = fs.mkdtempSync(path.join(resolvedTmpRoot, "ws-lo-profile-"));
+  if (!isInsidePath(resolvedTmpRoot, profile)) {
+    return { ok: false, error: { type: "profile_outside_tmp", message: `LibreOffice profile \u8D8A\u51FA\u4E34\u65F6\u6839\uFF1A${profile}` } };
+  }
+  const configDir = path.join(profile, "xdg_config");
+  const cacheDir = path.join(profile, "xdg_cache");
+  const tempDir = path.join(profile, "tmp");
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.mkdirSync(cacheDir, { recursive: true });
+  fs.mkdirSync(tempDir, { recursive: true });
+  const childEnv = {
+    ...env,
+    HOME: profile,
+    XDG_CONFIG_HOME: configDir,
+    XDG_CACHE_HOME: cacheDir,
+    TEMP: tempDir,
+    TMP: tempDir
+  };
+  const timeoutMs = Math.min(Math.max((options.timeoutSeconds ?? 180) * 1e3, 1e4), 6e5);
+  const args = [
+    "--headless",
+    "--invisible",
+    "--norestore",
+    `-env:UserInstallation=${pathToFileURL(profile).href}`,
+    "--convert-to",
+    "pdf",
+    "--outdir",
+    outputDir,
+    resolvedInput
+  ];
+  try {
+    const result = await run(soffice.path, args, { env: childEnv, timeoutMs, signal: deps.signal });
+    const expectedPdf = path.join(outputDir, `${path.parse(resolvedInput).name}.pdf`);
+    if (!result.timedOut && result.exitCode === 0 && pathExists(expectedPdf) && fs.statSync(expectedPdf).size > 0) {
+      return {
+        ok: true,
+        pdfPath: expectedPdf,
+        soffice: { path: soffice.path, version: soffice.version },
+        durationMs: Date.now() - startedAt
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        type: result.timedOut ? "conversion_timeout" : "conversion_failed",
+        message: result.timedOut ? `LibreOffice \u8F6C\u6362\u8D85\u65F6\uFF08${timeoutMs / 1e3}s\uFF09` : `LibreOffice \u8F6C\u6362\u5931\u8D25\uFF08exit=${result.exitCode ?? "spawn-error"}\uFF09`,
+        exitCode: result.exitCode,
+        stderr: result.stderr || result.spawnError || void 0,
+        stdout: result.stdout || void 0
+      }
+    };
+  } finally {
+    fs.rmSync(profile, { recursive: true, force: true });
+  }
+}
+__name(convertDocxToPdf, "convertDocxToPdf");
+var PYMUPDF_RENDER_SCRIPT = [
+  "import sys, os, fitz",
+  "pdf, outdir, dpi = sys.argv[1], sys.argv[2], float(sys.argv[3])",
+  "first, last = int(sys.argv[4]), int(sys.argv[5])",
+  "doc = fitz.open(pdf)",
+  "zoom = dpi / 72.0",
+  "mat = fitz.Matrix(zoom, zoom)",
+  "total = doc.page_count",
+  "lo = max(first, 1)",
+  "hi = min(last, total) if last > 0 else total",
+  "count = 0",
+  "for pno in range(lo - 1, hi):",
+  "    pix = doc.load_page(pno).get_pixmap(matrix=mat)",
+  "    pix.save(os.path.join(outdir, f'page-{pno + 1}.png'))",
+  "    count += 1",
+  "print(f'pages={count}')"
+].join("\n");
+function collectPngs(dir) {
+  return fs.readdirSync(dir).filter((name) => /^page-\d+\.png$/i.test(name)).sort((a, b) => parseInt(/\d+/.exec(a)[0], 10) - parseInt(/\d+/.exec(b)[0], 10)).map((name) => path.join(dir, name));
+}
+__name(collectPngs, "collectPngs");
+async function convertPdfToPng(inputPath, options = {}, deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const pathExists = deps.pathExists ?? fs.existsSync;
+  const run = deps.run ?? defaultRunProcess;
+  const tmpRoot = deps.tmpRoot ?? os.tmpdir();
+  const resolvedInput = path.resolve(inputPath);
+  if (!pathExists(resolvedInput)) {
+    return { ok: false, error: { type: "input_not_found", message: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${resolvedInput}` } };
+  }
+  const dpi = Math.min(Math.max(Math.round(options.dpi ?? 150), 50), 400);
+  const firstPage = Math.max(1, Math.round(options.firstPage ?? 1));
+  const lastPage = Math.round(options.lastPage ?? 0);
+  const outputDir = path.resolve(
+    options.outputDir ?? path.join(path.dirname(resolvedInput), `${path.parse(resolvedInput).name}-pages`)
+  );
+  fs.mkdirSync(outputDir, { recursive: true });
+  const pdftoppm = await detectPdftoppm(deps);
+  if (pdftoppm.found && pdftoppm.path && pdftoppm.exists !== false) {
+    const pageArgs = [
+      ...firstPage > 1 ? ["-f", String(firstPage)] : [],
+      ...lastPage > 0 ? ["-l", String(lastPage)] : []
+    ];
+    if (platform === "win32") {
+      const workDir = fs.mkdtempSync(path.join(path.resolve(tmpRoot), "ws-poppler-"));
+      try {
+        const workPdf = path.join(workDir, "input.pdf");
+        fs.copyFileSync(resolvedInput, workPdf);
+        const result2 = await run(
+          pdftoppm.path,
+          ["-png", "-r", String(dpi), ...pageArgs, workPdf, path.join(workDir, "page")],
+          {
+            env,
+            timeoutMs: 3e5,
+            signal: deps.signal
+          }
+        );
+        const produced2 = collectPngs(workDir);
+        if (!result2.timedOut && result2.exitCode === 0 && produced2.length > 0) {
+          const pngPaths = [];
+          for (const producedPath of produced2) {
+            const pageNo = /\d+/.exec(path.basename(producedPath))[0];
+            const target = path.join(outputDir, `page-${parseInt(pageNo, 10)}.png`);
+            fs.copyFileSync(producedPath, target);
+            pngPaths.push(target);
+          }
+          return { ok: true, pngPaths, pageCount: pngPaths.length, engine: "pdftoppm", dpi, outputDir };
+        }
+        return {
+          ok: false,
+          error: {
+            type: result2.timedOut ? "conversion_timeout" : "conversion_failed",
+            message: `pdftoppm \u6E32\u67D3\u5931\u8D25\uFF08exit=${result2.exitCode ?? "spawn-error"}\uFF09`,
+            engine: "pdftoppm",
+            exitCode: result2.exitCode,
+            stderr: result2.stderr || result2.spawnError || void 0
+          }
+        };
+      } finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+      }
+    }
+    const result = await run(
+      pdftoppm.path,
+      ["-png", "-r", String(dpi), ...pageArgs, resolvedInput, path.join(outputDir, "page")],
+      {
+        env,
+        timeoutMs: 3e5,
+        signal: deps.signal
+      }
+    );
+    const produced = collectPngs(outputDir);
+    if (!result.timedOut && result.exitCode === 0 && produced.length > 0) {
+      return { ok: true, pngPaths: produced, pageCount: produced.length, engine: "pdftoppm", dpi, outputDir };
+    }
+    return {
+      ok: false,
+      error: {
+        type: result.timedOut ? "conversion_timeout" : "conversion_failed",
+        message: `pdftoppm \u6E32\u67D3\u5931\u8D25\uFF08exit=${result.exitCode ?? "spawn-error"}\uFF09`,
+        engine: "pdftoppm",
+        exitCode: result.exitCode,
+        stderr: result.stderr || result.spawnError || void 0
+      }
+    };
+  }
+  const pymupdf = await detectPyMuPDF(deps);
+  if (pymupdf.found && pymupdf.path) {
+    const result = await run(
+      pymupdf.path,
+      ["-c", PYMUPDF_RENDER_SCRIPT, resolvedInput, outputDir, String(dpi), String(firstPage), String(lastPage)],
+      { env, timeoutMs: 3e5, signal: deps.signal }
+    );
+    const produced = collectPngs(outputDir);
+    if (!result.timedOut && result.exitCode === 0 && produced.length > 0) {
+      return { ok: true, pngPaths: produced, pageCount: produced.length, engine: "pymupdf", dpi, outputDir };
+    }
+    return {
+      ok: false,
+      error: {
+        type: result.timedOut ? "conversion_timeout" : "conversion_failed",
+        message: `PyMuPDF \u6E32\u67D3\u5931\u8D25\uFF08exit=${result.exitCode ?? "spawn-error"}\uFF09`,
+        engine: "pymupdf",
+        exitCode: result.exitCode,
+        stderr: result.stderr || result.spawnError || void 0
+      }
+    };
+  }
+  return unavailableResult(
+    "pdftoppm+pymupdf",
+    "\u672C\u673A\u65E2\u672A\u627E\u5230 pdftoppm\uFF08poppler\uFF09\uFF0C\u4E5F\u672A\u627E\u5230\u88C5\u4E86 PyMuPDF \u7684 python\uFF0CPDF\u2192PNG \u6E32\u67D3\u4E0D\u53EF\u7528\u3002",
+    "\u88C5 poppler\uFF08Windows \u53D1\u884C\u5305\u89E3\u538B\u540E\u628A bin \u52A0 PATH\xB7macOS `brew install poppler`\xB7Linux `apt install poppler-utils`\uFF09\uFF0C\u6216 `pip install pymupdf`\uFF1B\u4EA6\u53EF\u7528 WS_PDFTOPPM / WS_PYTHON \u663E\u5F0F\u6307\u8DEF\u3002\u8BF7\u52FF\u73B0\u573A\u5199\u811A\u672C\u786C\u603C\u3002",
+    [...pdftoppm.probed, ...pymupdf.probed]
+  );
+}
+__name(convertPdfToPng, "convertPdfToPng");
+async function probeEnvironment(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const [soffice, pdftoppm, pymupdf] = await Promise.all([
+    detectSoffice(deps),
+    detectPdftoppm(deps),
+    detectPyMuPDF(deps)
+  ]);
+  const notes = [];
+  if (!soffice.found || soffice.exists === false) {
+    notes.push("docx\u2192PDF \u4E0D\u53EF\u7528\uFF1A\u672A\u627E\u5230 LibreOffice\u2014\u2014\u88C5 LibreOffice \u6216\u8BBE WS_SOFFICE \u540E\u91CD\u8BD5\uFF1B\u4E0D\u8981\u73B0\u573A\u5199\u4EE3\u7801\u786C\u603C\u3002");
+  }
+  if (!pdftoppm.found && !pymupdf.found) {
+    notes.push(
+      "PDF\u2192PNG \u4E0D\u53EF\u7528\uFF1Apdftoppm \u4E0E PyMuPDF \u53CC\u53CC\u7F3A\u5E2D\u2014\u2014\u88C5 poppler \u6216 `pip install pymupdf`\uFF1B\u4E0D\u8981\u73B0\u573A\u5199\u4EE3\u7801\u786C\u603C\u3002"
+    );
+  } else if (!pdftoppm.found) {
+    notes.push("pdftoppm \u7F3A\u5E2D\uFF0CPDF\u2192PNG \u8D70 PyMuPDF fallback\uFF08\u53EF\u7528\uFF09\u3002");
+  }
+  return {
+    platform,
+    node: process.version,
+    tools: { soffice, pdftoppm, pymupdf },
+    capabilities: {
+      read_docx: true,
+      write_docx: true,
+      edit_docx: true,
+      docx_to_pdf: soffice.found && soffice.exists !== false,
+      pdf_to_png: pdftoppm.found && pdftoppm.exists !== false || pymupdf.found
+    },
+    honest_notes: notes
+  };
+}
+__name(probeEnvironment, "probeEnvironment");
+
+// packages/core/src/mcp/servers/doc-toolchain-server.ts
+var DOC_TOOLCHAIN_SERVER_NAME = "doc_toolchain";
+var DOC_TOOLCHAIN_TOOL_PREFIX = "mcp__doc_toolchain__";
+var EDIT_OPS = ["replace_paragraph_text", "insert_paragraph", "delete_paragraph", "append_paragraph"];
+var DOC_TOOLCHAIN_TOOL_DEFINITIONS = [
+  {
+    name: "probe_environment",
+    description: "\u63A2\u6D4B\u672C\u673A\u6587\u6863\u5DE5\u5177\u94FE\u73AF\u5883\uFF1ALibreOffice\uFF08docx\u2192PDF\uFF09\u3001pdftoppm/PyMuPDF\uFF08PDF\u2192PNG\uFF09\u5728\u573A\u4E0E\u5426\u3001\u8DEF\u5F84\u4E0E\u7248\u672C\u3002docx \u8BFB/\u5199/\u6539\u4E3A\u7EAF\u5185\u7F6E\u80FD\u529B\u6052\u53EF\u7528\u3002\u8F6C\u6362\u7C7B\u4EFB\u52A1\u524D\u53EF\u5148\u63A2\u4E00\u6B21\uFF1B\u7F3A\u5931\u65F6\u5DE5\u5177\u4F1A\u8BDA\u5B9E\u964D\u7EA7\uFF0C\u4E0D\u8981\u73B0\u573A\u5199\u4EE3\u7801\u786C\u603C\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  },
+  {
+    name: "read_docx",
+    description: "\u8BFB docx\uFF1AOOXML \u89E3\u6790\u51FA\u6B63\u6587\u5757\u5E8F\u5217\uFF08\u6BB5\u843D\u951A paragraphIndex + \u6837\u5F0F + \u6587\u672C\uFF0C\u8868\u683C\u6309\u884C/\u683C\uFF09\u4E0E\u5B57\u6570\u7EDF\u8BA1\uFF1BincludeNotes=true \u65F6\u9644\u811A\u6CE8/\u5C3E\u6CE8/\u6279\u6CE8\u3002\u8868\u683C\u5185\u6BB5\u843D\u53EA\u8BFB\uFF08\u7F16\u8F91\u951A\u4E0D\u8986\u76D6\uFF09\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "docx \u6587\u4EF6\u8DEF\u5F84" },
+        includeNotes: { type: "boolean", default: false, description: "\u662F\u5426\u9644\u811A\u6CE8/\u5C3E\u6CE8/\u6279\u6CE8" }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  },
+  {
+    name: "write_docx",
+    description: "\u4ECE markdown \u5B50\u96C6\u65B0\u5EFA docx\uFF1A# / ## / ### \u6807\u9898\u3001- \u5217\u8868\u3001\u7A7A\u884C\u5206\u6BB5\uFF08\u6BB5\u5185\u6362\u884C\u6309 CJK \u53CB\u597D\u89C4\u5219\u62FC\u63A5\uFF09\u3002A4 \u7248\u5F0F\u3001Times New Roman/\u5B8B\u4F53\u57FA\u7EBF\u3002\u5DF2\u5B58\u5728\u6587\u4EF6\u987B overwrite=true \u624D\u8986\u76D6\u3002\u884C\u5185\u5B57\u7B26\u683C\u5F0F\uFF08\u7C97\u659C\u4F53\u7B49\uFF09v1 \u4E0D\u652F\u6301\uFF0C\u5982\u5B9E\u77E5\u6089\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8F93\u51FA docx \u8DEF\u5F84" },
+        markdown: { type: "string", description: "markdown \u5B50\u96C6\u6B63\u6587" },
+        overwrite: { type: "boolean", default: false }
+      },
+      required: ["path", "markdown"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  },
+  {
+    name: "edit_docx",
+    description: "\u6BB5\u843D\u951A\u5B9A\u7F16\u8F91\u65E2\u6709 docx\uFF1Aops \u5168\u90E8\u951A\u5B9A\u300C\u7F16\u8F91\u524D\u300D\u6BB5\u843D\u7F16\u53F7\uFF08read_docx \u7684 paragraphIndex\uFF09\uFF0C\u4E00\u6B21\u6027\u5957\u7528\u3002\u64CD\u4F5C\uFF1Areplace_paragraph_text\uFF08\u6362\u6587\xB7\u4FDD\u7559\u6BB5\u843D\u7EA7\u683C\u5F0F\xB7run \u7EA7\u5B57\u7B26\u683C\u5F0F\u5F52\u4E00\uFF09/ insert_paragraph\uFF08before|after\uFF09/ delete_paragraph / append_paragraph\u3002\u53EA\u91CD\u5199 document.xml\uFF0C\u5176\u4F59\u5305\u5185\u5BB9\u5B57\u8282\u539F\u6837\u4FDD\u7559\u3002\u9ED8\u8BA4\u539F\u5730\u8986\u76D6\u5E76\u7559 .bak-\u65F6\u95F4\u6233 \u5907\u4EFD\uFF1B\u7ED9 outputPath \u5219\u53E6\u5B58\u3002\u8868\u683C\u5185\u6BB5\u843D\u3001\u4FEE\u8BA2/\u6279\u6CE8\u751F\u6210 v1 \u4E0D\u652F\u6301\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8F93\u5165 docx \u8DEF\u5F84" },
+        ops: {
+          type: "array",
+          description: "\u7F16\u8F91\u64CD\u4F5C\u5E8F\u5217\uFF08\u951A\u5B9A\u7F16\u8F91\u524D\u6BB5\u843D\u7F16\u53F7\uFF09",
+          items: {
+            type: "object",
+            properties: {
+              op: { type: "string", enum: [...EDIT_OPS] },
+              index: { type: "number" },
+              position: { type: "string", enum: ["before", "after"] },
+              text: { type: "string" },
+              style: { type: "string" }
+            },
+            required: ["op"]
+          }
+        },
+        outputPath: { type: "string", description: "\u53E6\u5B58\u8DEF\u5F84\uFF08\u7F3A\u7701=\u539F\u5730\u8986\u76D6+\u81EA\u52A8\u5907\u4EFD\uFF09" }
+      },
+      required: ["path", "ops"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  },
+  {
+    name: "docx_to_pdf",
+    description: "docx \u8F6C PDF\uFF1ALibreOffice headless \u96C6\u6210\uFF08soffice \u63A2\u6D4B\uFF1AWS_SOFFICE > PATH > \u5468\u77E5\u5B89\u88C5\u4F4D\uFF1B\u72EC\u7ACB -env:UserInstallation profile \u843D\u4E34\u65F6\u76EE\u5F55\uFF1BLibreOffice \u5B89\u88C5\u76EE\u5F55\u7EDD\u5BF9\u7981\u5199\uFF09\u3002\u73AF\u5883\u7F3A\u5931\u8FD4\u56DE tool_unavailable \u8BDA\u5B9E\u964D\u7EA7+\u5B89\u88C5\u6307\u5F15\uFF0C\u6B64\u65F6\u5982\u5B9E\u544A\u77E5\u7528\u6237\uFF0C\u4E0D\u8981\u73B0\u573A\u5199\u4EE3\u7801\u786C\u603C\u3002\u8F93\u51FA\u9ED8\u8BA4\u4E0E\u8F93\u5165\u540C\u76EE\u5F55\u540C\u540D .pdf\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8F93\u5165 docx \u8DEF\u5F84" },
+        outputDir: { type: "string", description: "PDF \u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701=\u8F93\u5165\u6587\u4EF6\u6240\u5728\u76EE\u5F55\uFF09" },
+        timeoutSeconds: { type: "number", description: "\u8F6C\u6362\u8D85\u65F6\u79D2\u6570\uFF08\u9ED8\u8BA4 180\xB7\u4E0A\u9650 600\uFF09" }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  },
+  {
+    name: "pdf_to_png",
+    description: "PDF \u6E32\u67D3\u4E3A\u9010\u9875 PNG\uFF1Apdftoppm \u4F18\u5148\u3001PyMuPDF fallback\uFF08\u63A2\u6D4B\uFF1AWS_PDFTOPPM/WS_PYTHON > PATH > \u5468\u77E5\u4F4D\uFF1Bwin32 \u4E00\u5F8B\u5728 ASCII \u4E34\u65F6\u76EE\u5F55\u8DD1 poppler \u518D\u62F7\u56DE\uFF09\u3002\u4EA7\u7269 page-<\u9875\u7801>.png \u8DEF\u5F84\u5217\u8868\u76F4\u63A5\u7ED9\u89C6\u89C9\u901A\u9053\u770B\u56FE\u9A8C\u6536\u3002\u53CC\u7F3A\u5E2D\u8FD4\u56DE tool_unavailable \u8BDA\u5B9E\u964D\u7EA7+\u5B89\u88C5\u6307\u5F15\uFF0C\u4E0D\u8981\u73B0\u573A\u5199\u4EE3\u7801\u786C\u603C\u3002",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u8F93\u5165 PDF \u8DEF\u5F84" },
+        outputDir: { type: "string", description: "PNG \u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701=<PDF\u76EE\u5F55>/<\u539F\u540D>-pages/\uFF09" },
+        dpi: { type: "number", description: "\u6E32\u67D3 DPI\uFF08\u9ED8\u8BA4 150\xB7\u8303\u56F4 50-400\uFF09" },
+        firstPage: { type: "number", description: "\u8D77\u59CB\u9875\uFF08\u9ED8\u8BA4 1\uFF09" },
+        lastPage: { type: "number", description: "\u622A\u6B62\u9875\uFF08\u9ED8\u8BA4 0=\u5230\u672B\u9875\uFF09" }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  }
+];
+function textResult(text, isError = false) {
+  return {
+    content: [{ type: "text", text }],
+    ...isError ? { isError: true } : {}
+  };
+}
+__name(textResult, "textResult");
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+__name(asObject, "asObject");
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+__name(asString, "asString");
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(asNumber, "asNumber");
+function errorResult(error) {
+  if (error instanceof OoxmlFormatError || error instanceof ZipFormatError) {
+    return textResult(JSON.stringify({ error: { type: "bad_document", message: error.message } }), true);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return textResult(JSON.stringify({ error: { type: "internal_error", message } }), true);
+}
+__name(errorResult, "errorResult");
+function backupPathFor(target) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${target}.bak-${stamp}`;
+}
+__name(backupPathFor, "backupPathFor");
+async function executeDocToolchainTool(name, args, deps = {}) {
+  const record = asObject(args) ?? {};
+  try {
+    if (name === "probe_environment") {
+      return textResult(JSON.stringify(await probeEnvironment(deps)));
+    }
+    if (name === "read_docx") {
+      const target = asString(record.path);
+      if (!target)
+        return textResult(JSON.stringify({ error: { type: "invalid_arguments", message: "\u7F3A path" } }), true);
+      const resolved = path2.resolve(target);
+      if (!fs2.existsSync(resolved)) {
+        return textResult(
+          JSON.stringify({ error: { type: "input_not_found", message: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${resolved}` } }),
+          true
+        );
+      }
+      const result = readDocx(fs2.readFileSync(resolved), {
+        includeNotes: record.includeNotes === true
+      });
+      return textResult(JSON.stringify(result));
+    }
+    if (name === "write_docx") {
+      const target = asString(record.path);
+      const markdown = typeof record.markdown === "string" ? record.markdown : null;
+      if (!target || markdown === null) {
+        return textResult(
+          JSON.stringify({ error: { type: "invalid_arguments", message: "\u7F3A path \u6216 markdown" } }),
+          true
+        );
+      }
+      const resolved = path2.resolve(target);
+      if (fs2.existsSync(resolved) && record.overwrite !== true) {
+        return textResult(
+          JSON.stringify({
+            error: { type: "already_exists", message: `\u6587\u4EF6\u5DF2\u5B58\u5728\uFF08\u987B overwrite=true \u624D\u8986\u76D6\uFF09\uFF1A${resolved}` }
+          }),
+          true
+        );
+      }
+      fs2.mkdirSync(path2.dirname(resolved), { recursive: true });
+      fs2.writeFileSync(resolved, buildDocx(markdown));
+      return textResult(JSON.stringify({ ok: true, path: resolved, bytes: fs2.statSync(resolved).size }));
+    }
+    if (name === "edit_docx") {
+      const target = asString(record.path);
+      if (!target || !Array.isArray(record.ops)) {
+        return textResult(JSON.stringify({ error: { type: "invalid_arguments", message: "\u7F3A path \u6216 ops" } }), true);
+      }
+      const ops = record.ops;
+      const resolved = path2.resolve(target);
+      if (!fs2.existsSync(resolved)) {
+        return textResult(
+          JSON.stringify({ error: { type: "input_not_found", message: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${resolved}` } }),
+          true
+        );
+      }
+      const result = editDocx(fs2.readFileSync(resolved), ops);
+      const output = asString(record.outputPath) ? path2.resolve(record.outputPath) : resolved;
+      fs2.mkdirSync(path2.dirname(output), { recursive: true });
+      let backup = null;
+      if (output === resolved) {
+        backup = backupPathFor(resolved);
+        fs2.copyFileSync(resolved, backup);
+      }
+      fs2.writeFileSync(output, result.buffer);
+      return textResult(
+        JSON.stringify({
+          ok: true,
+          path: output,
+          backup,
+          applied: result.applied,
+          paragraphCountBefore: result.paragraphCountBefore,
+          paragraphCountAfter: result.paragraphCountAfter
+        })
+      );
+    }
+    if (name === "docx_to_pdf") {
+      const target = asString(record.path);
+      if (!target)
+        return textResult(JSON.stringify({ error: { type: "invalid_arguments", message: "\u7F3A path" } }), true);
+      const result = await convertDocxToPdf(
+        target,
+        { outputDir: asString(record.outputDir) ?? void 0, timeoutSeconds: asNumber(record.timeoutSeconds) },
+        deps
+      );
+      return textResult(JSON.stringify(result), !result.ok);
+    }
+    if (name === "pdf_to_png") {
+      const target = asString(record.path);
+      if (!target)
+        return textResult(JSON.stringify({ error: { type: "invalid_arguments", message: "\u7F3A path" } }), true);
+      const result = await convertPdfToPng(
+        target,
+        {
+          outputDir: asString(record.outputDir) ?? void 0,
+          dpi: asNumber(record.dpi),
+          firstPage: asNumber(record.firstPage),
+          lastPage: asNumber(record.lastPage)
+        },
+        deps
+      );
+      return textResult(JSON.stringify(result), !result.ok);
+    }
+    return textResult(JSON.stringify({ error: { type: "unknown_tool", message: name } }), true);
+  } catch (error) {
+    return errorResult(error);
+  }
+}
+__name(executeDocToolchainTool, "executeDocToolchainTool");
+var activeToolCalls = /* @__PURE__ */ new Map();
+function send(value) {
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+__name(send, "send");
+async function handleRpc(message) {
+  if (typeof message.method !== "string") return;
+  if (message.method === "notifications/cancelled") {
+    const params = asObject(message.params);
+    activeToolCalls.get(params?.requestId)?.abort();
+    return;
+  }
+  if (message.id === void 0) return;
+  let result;
+  if (message.method === "initialize") {
+    result = {
+      protocolVersion: "2025-03-26",
+      capabilities: { tools: {} },
+      serverInfo: { name: DOC_TOOLCHAIN_SERVER_NAME, version: "1.0.0" }
+    };
+  } else if (message.method === "tools/list") {
+    result = { tools: DOC_TOOLCHAIN_TOOL_DEFINITIONS };
+  } else if (message.method === "tools/call") {
+    const params = asObject(message.params);
+    const controller = new AbortController();
+    activeToolCalls.set(message.id, controller);
+    try {
+      result = await executeDocToolchainTool(String(params?.name ?? ""), params?.arguments, {
+        signal: controller.signal
+      });
+    } finally {
+      activeToolCalls.delete(message.id);
+    }
+  } else if (message.method === "prompts/list") {
+    result = { prompts: [] };
+  } else if (message.method === "resources/list") {
+    result = { resources: [] };
+  } else {
+    send({
+      jsonrpc: "2.0",
+      id: message.id,
+      error: { code: -32601, message: "Method not found" }
+    });
+    return;
+  }
+  send({ jsonrpc: "2.0", id: message.id, result });
+}
+__name(handleRpc, "handleRpc");
+function runDocToolchainMcpServer() {
+  const reader = createInterface({ input: process.stdin });
+  reader.on("line", (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      void handleRpc(parsed);
+    }
+  });
+}
+__name(runDocToolchainMcpServer, "runDocToolchainMcpServer");
+var invokedPath = process.argv[1] ? path2.resolve(process.argv[1]) : "";
+var invokedBasename = invokedPath ? path2.basename(invokedPath).replace(/\.(?:[cm]?js|ts)$/, "") : "";
+if (invokedPath && (path2.resolve(fileURLToPath(import.meta.url)) === invokedPath || invokedBasename === "doc-toolchain-server")) {
+  runDocToolchainMcpServer();
+}
+export {
+  DOC_TOOLCHAIN_SERVER_NAME,
+  DOC_TOOLCHAIN_TOOL_DEFINITIONS,
+  DOC_TOOLCHAIN_TOOL_PREFIX,
+  executeDocToolchainTool,
+  runDocToolchainMcpServer
+};