kordoc 4.0.8 → 4.2.0

package/dist/mcp.js

@@ -31,34 +31,42 @@ import {
   patchHwp,
   patchHwpx,
   unknownFontWarnings
-} from "./chunk-7S3M4N4E.js";
-import {
-  blocksToMarkdown
-} from "./chunk-UEIYETCQ.js";
+} from "./chunk-IGGRLWT5.js";
+import "./chunk-7FCNOKOR.js";
+import "./chunk-4VNLZ2GZ.js";
 import {
   detectFormat,
   detectZipFormat
-} from "./chunk-MEPHGCPQ.js";
+} from "./chunk-YOO6ET6M.js";
 import "./chunk-MOL7MDBG.js";
-import "./chunk-D35VBACN.js";
-import "./chunk-2DZQF6YJ.js";
-import "./chunk-BNU5QGIZ.js";
+import "./chunk-WQLHPOMJ.js";
+import "./chunk-DZIXKL7E.js";
+import "./chunk-ELOV2GIJ.js";
+import {
+  blocksToMarkdown
+} from "./chunk-CMN3SYZ3.js";
+import "./chunk-6SHO3BNV.js";
+import "./chunk-V6U6YS5B.js";
 import {
   KordocError,
   VERSION,
+  classifyError,
   sanitizeError,
   toArrayBuffer
-} from "./chunk-HMUEU7D7.js";
+} from "./chunk-FSXLSHCW.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { readFileSync, writeFileSync, realpathSync, openSync, readSync, closeSync, statSync, mkdirSync } from "fs";
-import { resolve, isAbsolute, extname, dirname } from "path";
-var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".hwp", ".hwpx", ".pdf", ".xlsx", ".docx"]);
+import { readFileSync, writeFileSync, realpathSync, openSync, readSync, closeSync, statSync, mkdirSync, existsSync } from "fs";
+import { pathToFileURL } from "url";
+import { resolve, isAbsolute, extname, dirname, basename } from "path";
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".hwp", ".hwpx", ".hml", ".pdf", ".xls", ".xlsx", ".docx"]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".bmp"]);
+var PROFILE_EXTENSIONS = /* @__PURE__ */ new Set([".json"]);
 var MAX_FILE_SIZE = 500 * 1024 * 1024;
-function safePath(filePath) {
+function safePath(filePath, allowedExts = ALLOWED_EXTENSIONS) {
   if (!filePath) throw new KordocError("\uD30C\uC77C \uACBD\uB85C\uAC00 \uBE44\uC5B4\uC788\uC2B5\uB2C8\uB2E4");
   const resolved = resolve(filePath);
   let real;
@@ -71,12 +79,53 @@ function safePath(filePath) {
   }
   if (!isAbsolute(real)) throw new KordocError("\uC808\uB300 \uACBD\uB85C\uB9CC \uD5C8\uC6A9\uB429\uB2C8\uB2E4");
   const ext = extname(real).toLowerCase();
-  if (!ALLOWED_EXTENSIONS.has(ext)) throw new KordocError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD655\uC7A5\uC790\uC785\uB2C8\uB2E4: ${ext} (\uD5C8\uC6A9: ${[...ALLOWED_EXTENSIONS].join(", ")})`);
+  if (!allowedExts.has(ext)) throw new KordocError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD655\uC7A5\uC790\uC785\uB2C8\uB2E4: ${ext} (\uD5C8\uC6A9: ${[...allowedExts].join(", ")})`);
   return real;
 }
+function safeOutputPath(outputPath, allowedExts) {
+  if (!outputPath) throw new KordocError("\uCD9C\uB825 \uACBD\uB85C\uAC00 \uBE44\uC5B4\uC788\uC2B5\uB2C8\uB2E4");
+  const resolved = resolve(outputPath);
+  const ext = extname(resolved).toLowerCase();
+  if (!allowedExts.has(ext)) {
+    throw new KordocError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uCD9C\uB825 \uD655\uC7A5\uC790\uC785\uB2C8\uB2E4: ${ext || "(\uC5C6\uC74C)"} (\uD5C8\uC6A9: ${[...allowedExts].join(", ")})`);
+  }
+  const parent = dirname(resolved);
+  if (existsSync(parent)) {
+    try {
+      return resolve(realpathSync(parent), basename(resolved));
+    } catch (err) {
+      throw new KordocError(`\uCD9C\uB825 \uACBD\uB85C \uCC98\uB9AC \uC624\uB958 [${err?.code ?? "UNKNOWN"}]: ${parent}`);
+    }
+  }
+  return resolved;
+}
+function describeError(err) {
+  if (err instanceof KordocError) return err.message;
+  const code = err?.code;
+  if (typeof code === "string" && /^E[A-Z]+$/.test(code)) {
+    const hints = {
+      ENOENT: "\uD30C\uC77C \uB610\uB294 \uB514\uB809\uD1A0\uB9AC\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      EACCES: "\uC811\uADFC \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4",
+      EPERM: "\uC791\uC5C5 \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4",
+      EISDIR: "\uD30C\uC77C\uC774 \uC544\uB2C8\uB77C \uB514\uB809\uD1A0\uB9AC\uC785\uB2C8\uB2E4",
+      ENOTDIR: "\uACBD\uB85C \uC911\uAC04\uC774 \uB514\uB809\uD1A0\uB9AC\uAC00 \uC544\uB2D9\uB2C8\uB2E4",
+      ENOSPC: "\uB514\uC2A4\uD06C \uACF5\uAC04\uC774 \uBD80\uC871\uD569\uB2C8\uB2E4"
+    };
+    return `\uD30C\uC77C \uC2DC\uC2A4\uD15C \uC624\uB958 [${code}]: ${hints[code] ?? "\uACBD\uB85C\uC640 \uAD8C\uD55C\uC744 \uD655\uC778\uD558\uC138\uC694"}`;
+  }
+  const cls = classifyError(err);
+  return cls === "PARSE_ERROR" ? sanitizeError(err) : `\uBB38\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4 (${cls})`;
+}
+var MAX_RESPONSE_CHARS = 2e5;
+function capResponseText(text, maxChars = MAX_RESPONSE_CHARS) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `
+
+\u2026 [\uC751\uB2F5\uC774 ${maxChars.toLocaleString()}\uC790 \uC0C1\uD55C\uC744 \uB118\uC5B4 \uC808\uB2E8\uB428 (\uC804\uCCB4 ${text.length.toLocaleString()}\uC790) \u2014 parse_pages\uB85C \uD398\uC774\uC9C0 \uBC94\uC704\uB97C \uB098\uB220 \uC77D\uC73C\uC138\uC694]`;
+}
 var MAX_METADATA_FILE_SIZE = 50 * 1024 * 1024;
-function readValidatedFile(filePath, maxSize = MAX_FILE_SIZE) {
-  const resolved = safePath(filePath);
+function readValidatedFile(filePath, maxSize = MAX_FILE_SIZE, allowedExts = ALLOWED_EXTENSIONS) {
+  const resolved = safePath(filePath, allowedExts);
   let fileSize;
   try {
     fileSize = statSync(resolved).size;
@@ -97,9 +146,9 @@ function readValidatedFile(filePath, maxSize = MAX_FILE_SIZE) {
 function detectFormatFromHeader(resolved) {
   const fd = openSync(resolved, "r");
   try {
-    const headerBuf = Buffer.alloc(16);
-    readSync(fd, headerBuf, 0, 16, 0);
-    return detectFormat(toArrayBuffer(headerBuf));
+    const headerBuf = Buffer.alloc(512);
+    const bytesRead = readSync(fd, headerBuf, 0, 512, 0);
+    return detectFormat(toArrayBuffer(headerBuf.subarray(0, bytesRead)));
   } finally {
     closeSync(fd);
   }
@@ -112,11 +161,12 @@ server.tool(
   "parse_document",
   "\uD55C\uAD6D \uBB38\uC11C \uD30C\uC77C(HWP, HWPX, PDF, XLSX, DOCX)\uC744 \uB9C8\uD06C\uB2E4\uC6B4\uC73C\uB85C \uBCC0\uD658\uD569\uB2C8\uB2E4. \uD30C\uC77C \uACBD\uB85C\uB97C \uC785\uB825\uD558\uBA74 \uD3EC\uB9F7\uC744 \uC790\uB3D9 \uAC10\uC9C0\uD558\uC5EC \uD14D\uC2A4\uD2B8\uB97C \uCD94\uCD9C\uD569\uB2C8\uB2E4.",
   {
-    file_path: z.string().min(1).describe("\uD30C\uC2F1\uD560 \uBB38\uC11C \uD30C\uC77C\uC758 \uC808\uB300 \uACBD\uB85C (HWP, HWPX, PDF, XLSX, DOCX)")
+    file_path: z.string().min(1).describe("\uD30C\uC2F1\uD560 \uBB38\uC11C \uD30C\uC77C\uC758 \uC808\uB300 \uACBD\uB85C (HWP, HWPX, PDF, XLSX, DOCX)"),
+    ocr: z.boolean().optional().describe("\uC2A4\uCE94/\uC774\uBBF8\uC9C0 PDF \uD14D\uC2A4\uD2B8 OCR (\uB0B4\uC7A5 PP-OCRv5 korean, \uCCAB \uC0AC\uC6A9 \uC2DC ~18MB \uC790\uB3D9 \uB2E4\uC6B4\uB85C\uB4DC). \uD14D\uC2A4\uD2B8\uCE35\uC774 \uC5C6\uAC70\uB098 \uAE68\uC9C4 \uD398\uC774\uC9C0\uB9CC \uC778\uC2DD\uD558\uACE0 \uC815\uC0C1 \uD398\uC774\uC9C0\uB294 \uADF8\uB300\uB85C \uB461\uB2C8\uB2E4. parse \uACB0\uACFC\uC5D0 NEEDS_OCR \uACBD\uACE0\uAC00 \uC788\uC73C\uBA74 \uC774 \uC635\uC158\uC73C\uB85C \uC7AC\uC2DC\uB3C4\uD558\uC138\uC694")
   },
-  async ({ file_path }) => {
+  async ({ file_path, ocr }) => {
     try {
-      const { buffer } = readValidatedFile(file_path);
+      const { buffer, resolved } = readValidatedFile(file_path);
       const format = detectFormat(buffer);
       if (format === "unknown") {
         return {
@@ -124,7 +174,7 @@ server.tool(
           isError: true
         };
       }
-      const result = await parse(buffer);
+      const result = await parse(buffer, { filePath: resolved, ...ocr ? { ocr: true } : {} });
       if (!result.success) {
         return {
           content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328 (${result.fileType}): ${result.error}` }],
@@ -137,7 +187,7 @@ server.tool(
         result.pageCount ? `\uD398\uC774\uC9C0: ${result.pageCount}` : null,
         result.metadata?.title ? `\uC81C\uBAA9: ${result.metadata.title}` : null,
         result.metadata?.author ? `\uC791\uC131\uC790: ${result.metadata.author}` : null,
-        result.isImageBased ? "\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uBD88\uAC00)" : null
+        result.isImageBased ? result.warnings?.some((w) => w.code === "OCR_APPLIED") ? "\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (OCR \uC801\uC6A9)" : "\uC774\uBBF8\uC9C0 \uAE30\uBC18 PDF (\uD14D\uC2A4\uD2B8 \uCD94\uCD9C \uBD88\uAC00 \u2014 ocr: true \uB85C \uC7AC\uC2DC\uB3C4 \uAC00\uB2A5)" : null
       ].filter(Boolean).join(" | ");
       const parts = [`[${meta}]`];
       if (result.outline && result.outline.length > 0) {
@@ -156,11 +206,11 @@ ${warnText}`);
 
 ${markdown}`);
       return {
-        content: [{ type: "text", text: parts.join("") }]
+        content: [{ type: "text", text: capResponseText(parts.join("")) }]
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -177,7 +227,7 @@ server.tool(
       const resolved = safePath(file_path);
       let format = detectFormatFromHeader(resolved);
       if (format === "hwpx") {
-        const { buffer } = readValidatedFile(file_path, MAX_METADATA_FILE_SIZE);
+        const { buffer } = readValidatedFile(file_path);
         format = await detectZipFormat(buffer);
       }
       return {
@@ -185,7 +235,7 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -211,7 +261,7 @@ server.tool(
       let metadata;
       let effectiveFormat = format;
       if (format === "hwpx") {
-        const { detectZipFormat: detectZipFormat2 } = await import("./detect-RI2MQ33K.js");
+        const { detectZipFormat: detectZipFormat2 } = await import("./detect-YEZX2XCF.js");
         const zipFormat = await detectZipFormat2(buffer);
         if (zipFormat === "xlsx" || zipFormat === "docx") effectiveFormat = zipFormat;
       }
@@ -224,12 +274,14 @@ server.tool(
           break;
         case "pdf":
           try {
-            const { extractPdfMetadataOnly } = await import("./parser-TCTCSBYZ.js");
+            const { extractPdfMetadataOnly } = await import("./parser-RBZHA6SY.js");
             metadata = await extractPdfMetadataOnly(buffer);
           } catch {
             metadata = void 0;
           }
           break;
+        case "hwp3":
+        case "hwpml":
         case "xlsx":
         case "docx": {
           const result = await parse(buffer);
@@ -242,7 +294,7 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -284,7 +336,7 @@ ${result.markdown}` }]
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -336,7 +388,7 @@ ${tableMarkdown}` }]
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -371,7 +423,7 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -386,7 +438,7 @@ server.tool(
   async ({ file_path }) => {
     try {
       const { buffer } = readValidatedFile(file_path);
-      const result = await parse(buffer);
+      const result = await parse(buffer, { keepTrailingEmptyCols: true });
       if (!result.success) {
         return {
           content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328: ${result.error}` }],
@@ -399,7 +451,7 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -427,6 +479,8 @@ server.tool(
   },
   async ({ file_path, fields, formats, require_unique, mask_values, output_format, output_path }) => {
     try {
+      const outExts = output_format === "markdown" ? /* @__PURE__ */ new Set([".md", ".markdown", ".txt"]) : /* @__PURE__ */ new Set([".hwpx"]);
+      const outPath = output_path ? safeOutputPath(output_path, outExts) : void 0;
       const { buffer } = readValidatedFile(file_path);
       if (output_format === "hwpx-preserve") {
         const format = detectFormat(buffer);
@@ -458,16 +512,16 @@ server.tool(
           verifyLine
         ].filter(Boolean).join(" | ");
         const filledList = hwpxResult.filled.map((f) => `  - ${f.label}: ${mask_values ? `[${[...f.value].length}\uC790]` : f.value}`).join("\n");
-        if (output_path) {
-          mkdirSync(dirname(resolve(output_path)), { recursive: true });
-          writeFileSync(resolve(output_path), Buffer.from(hwpxResult.buffer));
+        if (outPath) {
+          mkdirSync(dirname(outPath), { recursive: true });
+          writeFileSync(outPath, Buffer.from(hwpxResult.buffer));
           return {
             content: [{ type: "text", text: `[${summary2}]
 
 \uCC44\uC6CC\uC9C4 \uD544\uB4DC:
 ${filledList}
 
-HWPX \uD30C\uC77C \uC800\uC7A5 (\uC6D0\uBCF8 \uC11C\uC2DD \uC720\uC9C0): ${resolve(output_path)}` }]
+HWPX \uD30C\uC77C \uC800\uC7A5 (\uC6D0\uBCF8 \uC11C\uC2DD \uC720\uC9C0): ${outPath}` }]
           };
         }
         return {
@@ -479,7 +533,7 @@ ${filledList}
 \u26A0\uFE0F output_path\uB97C \uC9C0\uC815\uD558\uBA74 \uC6D0\uBCF8 \uC11C\uC2DD\uC774 \uC720\uC9C0\uB41C HWPX \uD30C\uC77C\uB85C \uC800\uC7A5\uB429\uB2C8\uB2E4.` }]
         };
       }
-      const result = await parse(buffer);
+      const result = await parse(buffer, { keepTrailingEmptyCols: true });
       if (!result.success) {
         return {
           content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328: ${result.error}` }],
@@ -505,13 +559,13 @@ ${filledList}
       ].filter(Boolean).join(" | ");
       if (output_format === "hwpx") {
         const hwpxBuffer = await markdownToHwpx(markdown);
-        if (output_path) {
-          mkdirSync(dirname(resolve(output_path)), { recursive: true });
-          writeFileSync(resolve(output_path), Buffer.from(hwpxBuffer));
+        if (outPath) {
+          mkdirSync(dirname(outPath), { recursive: true });
+          writeFileSync(outPath, Buffer.from(hwpxBuffer));
           return {
             content: [{ type: "text", text: `[${summary}]
 
-HWPX \uD30C\uC77C \uC800\uC7A5: ${resolve(output_path)}` }]
+HWPX \uD30C\uC77C \uC800\uC7A5: ${outPath}` }]
           };
         }
         return {
@@ -522,13 +576,13 @@ HWPX \uD30C\uC77C \uC800\uC7A5: ${resolve(output_path)}` }]
 ${previewMd}` }]
         };
       }
-      if (output_path) {
-        mkdirSync(dirname(resolve(output_path)), { recursive: true });
-        writeFileSync(resolve(output_path), markdown, "utf-8");
+      if (outPath) {
+        mkdirSync(dirname(outPath), { recursive: true });
+        writeFileSync(outPath, markdown, "utf-8");
         return {
           content: [{ type: "text", text: `[${summary}]
 
-\uB9C8\uD06C\uB2E4\uC6B4 \uD30C\uC77C \uC800\uC7A5: ${resolve(output_path)}
+\uB9C8\uD06C\uB2E4\uC6B4 \uD30C\uC77C \uC800\uC7A5: ${outPath}
 
 ${previewMd}` }]
         };
@@ -540,7 +594,7 @@ ${previewMd}` }]
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -562,6 +616,7 @@ server.tool(
   },
   async ({ file_path, image_path, anchor, occurrence, size_mm, mode, dx_mm, dy_mm, output_path }) => {
     try {
+      const outPath = safeOutputPath(output_path, /* @__PURE__ */ new Set([".hwpx"]));
       const { buffer } = readValidatedFile(file_path);
       const format = detectFormat(buffer);
       if (format !== "hwpx") {
@@ -570,13 +625,13 @@ server.tool(
           isError: true
         };
       }
-      const imgResolved = resolve(image_path);
+      const imgResolved = safePath(image_path, IMAGE_EXTENSIONS);
       if (statSync(imgResolved).size > 500 * 1024 * 1024) {
         return { content: [{ type: "text", text: `\uB3C4\uC7A5 \uC774\uBBF8\uC9C0\uAC00 \uB108\uBB34 \uD07D\uB2C8\uB2E4 (${(statSync(imgResolved).size / 1024 / 1024).toFixed(0)}MB) \u2014 500MB \uC774\uD558\uC5EC\uC57C \uD569\uB2C8\uB2E4.` }], isError: true };
       }
       const image = new Uint8Array(readFileSync(imgResolved));
-      const ext = extname(image_path).slice(1).toLowerCase() || "png";
-      const { placeSealHwpx } = await import("./seal-R4TETA4C.js");
+      const ext = extname(imgResolved).slice(1).toLowerCase();
+      const { placeSealHwpx } = await import("./seal-D2QNXJVO.js");
       const result = await placeSealHwpx(buffer, [{
         anchor,
         occurrence,
@@ -587,8 +642,8 @@ server.tool(
         dxMm: dx_mm,
         dyMm: dy_mm
       }]);
-      mkdirSync(dirname(resolve(output_path)), { recursive: true });
-      writeFileSync(resolve(output_path), Buffer.from(result.buffer));
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, Buffer.from(result.buffer));
       const p0 = result.placed[0];
       const warnLines = (p0.warnings ?? []).map((w) => `
 \u26A0\uFE0F ${w}`).join("");
@@ -596,13 +651,13 @@ server.tool(
         content: [{
           type: "text",
           text: `\uB3C4\uC7A5 \uBC30\uCE58 \uC644\uB8CC: "${p0.anchor}" #${p0.occurrence} \u2192 ${p0.mode} (x ${p0.posXMm}mm, y ${p0.posYMm}mm, ${p0.sizeMm}mm\uAC01, ${p0.entry})
-\uC800\uC7A5: ${resolve(output_path)}${warnLines}
+\uC800\uC7A5: ${outPath}${warnLines}
 \uD45C/\uD398\uC774\uC9C0 \uBD88\uD655\uC7A5(\uAE00 \uC55E \uBD80\uC720) \u2014 \uD55C\uCEF4\uC5D0\uC11C \uC704\uCE58 \uD655\uC778 \uD6C4 dx_mm/dy_mm \uB85C \uBBF8\uC138\uC870\uC815 \uAC00\uB2A5\uD569\uB2C8\uB2E4.`
         }]
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uB3C4\uC7A5 \uBC30\uCE58 \uC2E4\uD328: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uB3C4\uC7A5 \uBC30\uCE58 \uC2E4\uD328: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -618,6 +673,7 @@ server.tool(
   },
   async ({ file_path, edited_markdown, output_path }) => {
     try {
+      const out = safeOutputPath(output_path, /* @__PURE__ */ new Set([".hwpx", ".hwp"]));
       const { buffer } = readValidatedFile(file_path);
       const format = detectFormat(buffer);
       let isHwpx = format === "hwpx";
@@ -639,7 +695,6 @@ server.tool(
           isError: true
         };
       }
-      const out = resolve(output_path);
       mkdirSync(dirname(out), { recursive: true });
       writeFileSync(out, Buffer.from(result.data));
       const v = result.verification?.stats;
@@ -655,12 +710,147 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "render_document",
+  "HWPX \uBB38\uC11C\uB97C \uC2E4\uC81C \uC870\uD310 \uADF8\uB300\uB85C \uB80C\uB354\uD574 PNG \uC774\uBBF8\uC9C0(\uB610\uB294 SVG \uD30C\uC77C)\uB85C \uB3CC\uB824\uC90D\uB2C8\uB2E4. generate_document\xB7fill_form\xB7patch_document\xB7place_seal \uACB0\uACFC\uBB3C\uC744 \uB208\uC73C\uB85C \uD655\uC778\uD558\uB294 \uC6A9\uB3C4 \u2014 \uC0DD\uC131/\uC218\uC815 \uD6C4 \uC774 \uB3C4\uAD6C\uB85C \uB80C\uB354\uD574 \uAE68\uC9D0\xB7\uC798\uB9BC\xB7\uBC30\uCE58\uB97C \uAC80\uC99D\uD558\uACE0 \uB2E4\uC2DC \uACE0\uCE58\uB294 \uB8E8\uD504\uB97C \uAD8C\uC7A5\uD569\uB2C8\uB2E4. \uD55C\uCEF4 \uC800\uC7A5\uBCF8\uC740 \uC870\uD310 \uCE90\uC2DC\uB85C, AI \uC0DD\uC131\uBCF8(\uCE90\uC2DC \uC5C6\uC74C)\uC740 \uC21C\uC218 \uC870\uD310 \uC5D4\uC9C4(reflow)\uC73C\uB85C \uB80C\uB354\uB418\uBA70 \uD6C4\uC790\uB294 \uD55C\uCEF4 \uC2E4\uC870\uD310\uC758 \uADFC\uC0AC\uC785\uB2C8\uB2E4 (\uCC38\uACE0\uC6A9 \uBBF8\uB9AC\uBCF4\uAE30).",
+  {
+    file_path: z.string().min(1).describe("\uB80C\uB354\uD560 HWPX \uD30C\uC77C\uC758 \uC808\uB300 \uACBD\uB85C"),
+    format: z.enum(["png", "svg"]).default("png").describe("png=\uC774\uBBF8\uC9C0\uB85C \uC751\uB2F5\uC5D0 \uC9C1\uC811 \uBC18\uD658 (sharp \uD544\uC694, \uAE30\uBCF8 \uC124\uCE58\uB428) / svg=output_path\uC5D0 \uD30C\uC77C \uC800\uC7A5"),
+    output_path: z.string().min(1).optional().describe("\uACB0\uACFC \uC800\uC7A5 \uACBD\uB85C (png\uB294 \uC120\uD0DD, svg\uB294 \uD544\uC218 \u2014 \uD655\uC7A5\uC790\uB294 format\uACFC \uC77C\uCE58)"),
+    highlights: z.array(z.string().min(1)).optional().describe("\uD615\uAD11\uD39C \uD45C\uC2DC\uD560 \uAC80\uC0C9\uC5B4 \uBAA9\uB85D \u2014 \uCC44\uC6B4 \uAC12\xB7\uC218\uC815 \uBB38\uAD6C \uC704\uCE58 \uD655\uC778\uC6A9"),
+    reflow_mode: z.enum(["keep", "charAll"]).default("keep").describe("reflow \uC904\uBC14\uAFC8: keep=\uC5B4\uC808 \uB2E8\uC704, charAll=\uAE00\uC790 \uB2E8\uC704")
+  },
+  async ({ file_path, format, output_path, highlights, reflow_mode }) => {
+    try {
+      if (format === "svg" && !output_path) {
+        return { content: [{ type: "text", text: 'format: "svg"\uB294 output_path(.svg)\uAC00 \uD544\uC218\uC785\uB2C8\uB2E4 \u2014 SVG \uC6D0\uBB38\uC740 \uCEE4\uC11C \uC751\uB2F5\uC5D0 \uC9C1\uC811 \uB2F4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.' }], isError: true };
+      }
+      const outPath = output_path ? safeOutputPath(output_path, /* @__PURE__ */ new Set([format === "png" ? ".png" : ".svg"])) : void 0;
+      const { buffer } = readValidatedFile(file_path, MAX_FILE_SIZE, /* @__PURE__ */ new Set([".hwpx"]));
+      const { renderHwpxToSvg } = await import("./render-4MG5QUDG.js");
+      const result = await renderHwpxToSvg(buffer, { highlights, reflow: true, reflowMode: reflow_mode });
+      const summary = [
+        `\uB80C\uB354 \uC644\uB8CC: ${result.pageCount}\uD398\uC774\uC9C0, ${Math.round(result.width)}x${Math.round(result.height)}pt (\uD14D\uC2A4\uD2B8 ${result.stats.texts}\xB7\uC774\uBBF8\uC9C0 ${result.stats.images}\xB7\uD45C ${result.stats.tables})`,
+        ...result.warnings.map((w) => `\u26A0\uFE0F ${w}`)
+      ];
+      if (format === "svg") {
+        mkdirSync(dirname(outPath), { recursive: true });
+        writeFileSync(outPath, result.svg, "utf-8");
+        summary.push(`\uC800\uC7A5: ${outPath}`);
+        return { content: [{ type: "text", text: summary.join("\n") }] };
+      }
+      const { rasterizeSvg } = await import("./rasterize-W2NEZUSW.js");
+      const raster = await rasterizeSvg(result.svg, result.width, result.height);
+      if (outPath) {
+        mkdirSync(dirname(outPath), { recursive: true });
+        writeFileSync(outPath, raster.png);
+        summary.push(`\uC800\uC7A5: ${outPath}`);
+      }
+      summary.push(`\uC774\uBBF8\uC9C0 ${raster.widthPx}x${raster.heightPx}px \u2014 \uC798\uB9BC\xB7\uACB9\uCE68\xB7\uBE48\uCE78\xB7\uD398\uC774\uC9C0 \uB118\uCE68\uC774 \uBCF4\uC774\uBA74 \uC6D0\uC778 \uD14D\uC2A4\uD2B8\uB97C \uC218\uC815\uD574 \uB2E4\uC2DC \uC0DD\uC131/\uD328\uCE58\uD558\uC138\uC694.`);
+      return {
+        content: [
+          { type: "image", data: raster.png.toString("base64"), mimeType: "image/png" },
+          { type: "text", text: summary.join("\n") }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `\uB80C\uB354 \uC2E4\uD328: ${describeError(err)}` }],
         isError: true
       };
     }
   }
 );
+server.tool(
+  "redact_document",
+  "\uBB38\uC11C\uC758 \uAC1C\uC778\uC815\uBCF4(\uC8FC\uBBFC\uBC88\uD638\xB7\uC804\uD654\xB7\uC774\uBA54\uC77C\xB7\uCE74\uB4DC\xB7\uACC4\uC88C)\uB97C \uD0D0\uC9C0\uD574 \uC11C\uC2DD \uBCF4\uC874 \uB9C8\uC2A4\uD0B9\uD569\uB2C8\uB2E4. HWPX/HWP\uB294 \uC6D0\uBCF8 \uC11C\uC2DD 1\uBC14\uC774\uD2B8 \uADF8\uB300\uB85C patch, \uADF8 \uC678 \uD3EC\uB9F7\uC740 \uB9C8\uC2A4\uD0B9\uB41C \uB9C8\uD06C\uB2E4\uC6B4\uC73C\uB85C \uCD9C\uB825. \uC790\uB3D9 \uAC80\uCD9C \uBCF4\uC870 \uB3C4\uAD6C \u2014 \uACB0\uACFC \uB9AC\uD3EC\uD2B8\uB97C \uC0AC\uB78C\uC774 \uCD5C\uC885 \uD655\uC778\uD574\uC57C \uD558\uBA70 \uC774\uBBF8\uC9C0 \uC548 \uD14D\uC2A4\uD2B8\uB294 \uD0D0\uC9C0\uD558\uC9C0 \uBABB\uD569\uB2C8\uB2E4. \uB9C8\uC2A4\uD0B9 \uD6C4 render_document\uB85C \uB208\uC73C\uB85C \uD655\uC778\uD558\uB294 \uAC83\uC744 \uAD8C\uC7A5\uD569\uB2C8\uB2E4.",
+  {
+    file_path: z.string().min(1).describe("\uB300\uC0C1 \uBB38\uC11C\uC758 \uC808\uB300 \uACBD\uB85C"),
+    rules: z.array(z.enum(["rrn", "phone", "email", "card", "account", "passport", "driver"])).optional().describe("\uC801\uC6A9 \uB8F0 (\uAE30\uBCF8: rrn\xB7phone\xB7email\xB7card\xB7account \u2014 passport\xB7driver\uB294 opt-in)"),
+    mask_char: z.string().min(1).max(1).optional().describe("\uB9C8\uC2A4\uD06C \uBB38\uC790 1\uAE00\uC790 (\uAE30\uBCF8: \u25CF)"),
+    output_path: z.string().min(1).optional().describe("\uCD9C\uB825 \uACBD\uB85C (HWPX/HWP\uB294 \uAC19\uC740 \uD655\uC7A5\uC790, \uADF8 \uC678\uB294 .md) \u2014 dry_run\uC774 \uC544\uB2C8\uBA74 \uD544\uC218"),
+    dry_run: z.boolean().default(false).describe("\uD0D0\uC9C0 \uB9AC\uD3EC\uD2B8\uB9CC \uBC18\uD658, \uD30C\uC77C \uBBF8\uC0DD\uC131")
+  },
+  async ({ file_path, rules, mask_char, output_path, dry_run }) => {
+    try {
+      const { buffer } = readValidatedFile(file_path);
+      const format = detectFormat(buffer);
+      const patchable = format === "hwpx" || format === "hwp";
+      if (!dry_run && !output_path) {
+        return { content: [{ type: "text", text: "output_path\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4 (\uD0D0\uC9C0\uB9CC \uC6D0\uD558\uBA74 dry_run: true)." }], isError: true };
+      }
+      const outPath = !dry_run ? safeOutputPath(output_path, new Set(patchable ? [format === "hwp" ? ".hwp" : ".hwpx"] : [".md", ".markdown", ".txt"])) : void 0;
+      const parsed = await parse(buffer, { filePath: file_path });
+      if (!parsed.success) {
+        return { content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328: ${parsed.error}` }], isError: true };
+      }
+      const { redactMarkdown } = await import("./redact-7ILEAUTS.js");
+      const r = redactMarkdown(parsed.markdown, { rules, maskChar: mask_char });
+      const byRule = /* @__PURE__ */ new Map();
+      for (const h of r.hits) byRule.set(h.rule, (byRule.get(h.rule) ?? 0) + 1);
+      const lines = [
+        `\uD0D0\uC9C0: ${r.hits.length}\uAC74 (${[...byRule.entries()].map(([k, v]) => `${k} ${v}`).join(", ") || "\uC5C6\uC74C"})`,
+        ...r.hits.map((h) => `  - [${h.rule}] ${h.masked}`)
+      ];
+      if (!dry_run && r.hits.length > 0) {
+        if (patchable) {
+          const original = new Uint8Array(buffer);
+          const result = format === "hwp" ? await patchHwp(original, r.text) : await patchHwpx(original, r.text);
+          if (!result.success || !result.data) {
+            return { content: [{ type: "text", text: `\uB9C8\uC2A4\uD0B9 \uD328\uCE58 \uC2E4\uD328: ${result.error ?? "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}` }], isError: true };
+          }
+          mkdirSync(dirname(outPath), { recursive: true });
+          writeFileSync(outPath, Buffer.from(result.data));
+          lines.push(`\uC800\uC7A5: ${outPath} (\uC6D0\uBCF8 \uC11C\uC2DD \uBCF4\uC874)`);
+          if (result.skipped.length > 0) {
+            lines.push(`\u26A0\uFE0F \uBBF8\uC801\uC6A9 ${result.skipped.length}\uAC74 \u2014 \uD574\uB2F9 \uC704\uCE58\uB294 \uC6D0\uBB38\uC774 \uB0A8\uC544 \uC788\uC73C\uB2C8 \uBC18\uB4DC\uC2DC \uC218\uB3D9 \uD655\uC778:`);
+            for (const s of result.skipped) lines.push(`  - ${s.reason}`);
+          }
+          lines.push("render_document\uB85C \uB9C8\uC2A4\uD0B9 \uACB0\uACFC\uB97C \uB208\uC73C\uB85C \uD655\uC778\uD558\uC138\uC694.");
+        } else {
+          mkdirSync(dirname(outPath), { recursive: true });
+          writeFileSync(outPath, r.text, "utf-8");
+          lines.push(`\uC800\uC7A5: ${outPath} (${format}\uB294 \uC11C\uC2DD \uBCF4\uC874 \uBBF8\uC9C0\uC6D0 \u2014 \uB9C8\uC2A4\uD0B9\uB41C \uB9C8\uD06C\uB2E4\uC6B4)`);
+        }
+      } else if (!dry_run) {
+        lines.push("\uD0D0\uC9C0 0\uAC74 \u2014 \uCD9C\uB825 \uD30C\uC77C\uC744 \uB9CC\uB4E4\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+      }
+      lines.push("\uC8FC\uC758: \uC790\uB3D9 \uAC80\uCD9C\uC740 \uBCF4\uC870 \uC218\uB2E8\uC785\uB2C8\uB2E4. \uC774\uBBF8\uC9C0 \uC18D \uD14D\uC2A4\uD2B8\xB7\uD45C\uAE30 \uBCC0\uD615\uC740 \uB193\uCE60 \uC218 \uC788\uC73C\uB2C8 \uCD5C\uC885 \uACF5\uAC1C \uC804 \uC0AC\uB78C \uAC80\uD1A0\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.");
+      return { content: [{ type: "text", text: capResponseText(lines.join("\n")) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `\uB9C8\uC2A4\uD0B9 \uC2E4\uD328: ${describeError(err)}` }], isError: true };
+    }
+  }
+);
+server.tool(
+  "parse_chunks",
+  "\uBB38\uC11C\uB97C RAG\uC6A9 \uAD6C\uC870 \uCCAD\uD06C JSON\uC73C\uB85C \uD30C\uC2F1\uD569\uB2C8\uB2E4. \uD5E4\uB529\xB7\uAC1C\uC870\uC2DD \uC704\uACC4(\u25A1\u25CB- / 1.\xB7\uAC00.\xB71))\uAC00 breadcrumb \uACBD\uB85C\uB85C \uBCF4\uC874\uB418\uACE0 \uD45C\uB294 \uB3C5\uB9BD \uCCAD\uD06C\uB85C \uB098\uC635\uB2C8\uB2E4 \u2014 \uC784\uBCA0\uB529\xB7\uC778\uB371\uC2F1 \uC804\uCC98\uB9AC\uC6A9. \uC790\uB974\uAE30(\uD1A0\uD070 \uC0C1\uD55C\xB7\uC624\uBC84\uB7A9)\uB294 \uC18C\uBE44\uC790 \uBAAB\uC785\uB2C8\uB2E4.",
+  {
+    file_path: z.string().min(1).describe("\uB300\uC0C1 \uBB38\uC11C\uC758 \uC808\uB300 \uACBD\uB85C (HWP/HWPX/PDF/XLSX/DOCX)"),
+    granularity: z.enum(["section", "block"]).default("section").describe("section=\uAC19\uC740 breadcrumb \uC544\uB798 \uC5F0\uC18D \uD14D\uC2A4\uD2B8 \uBCD1\uD569(\uAE30\uBCF8), block=IRBlock 1\uAC1C=\uCCAD\uD06C 1\uAC1C"),
+    include_table_cells: z.boolean().default(false).describe("\uD45C \uCCAD\uD06C\uC5D0 \uC140 \uD14D\uC2A4\uD2B8 2\uCC28\uC6D0 \uBC30\uC5F4 \uD3EC\uD568 \uC5EC\uBD80")
+  },
+  async ({ file_path, granularity, include_table_cells }) => {
+    try {
+      const { buffer } = readValidatedFile(file_path);
+      const parsed = await parse(buffer, { filePath: file_path });
+      if (!parsed.success) {
+        return { content: [{ type: "text", text: `\uD30C\uC2F1 \uC2E4\uD328: ${parsed.error}` }], isError: true };
+      }
+      const { blocksToChunks } = await import("./chunks-ZQEFAZNC.js");
+      const chunks = blocksToChunks(parsed.blocks, { granularity, includeTableCells: include_table_cells });
+      return { content: [{ type: "text", text: capResponseText(JSON.stringify(chunks, null, 2)) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `\uCCAD\uD06C \uD30C\uC2F1 \uC2E4\uD328: ${describeError(err)}` }], isError: true };
+    }
+  }
+);
 server.tool(
   "extract_profile",
   '\uCC38\uC870 HWPX \uBB38\uC11C\uC5D0\uC11C \uD45C \uC11C\uC2DD \uD504\uB85C\uD544(\uD14C\uB450\uB9AC\xB7\uC74C\uC601\xB7\uC5F4 \uB108\uBE44\xB7\uC140 \uAE00\uAF34)\uC744 JSON\uC73C\uB85C \uCD94\uCD9C\uD569\uB2C8\uB2E4. \uCD94\uCD9C\uD55C \uD504\uB85C\uD544\uC744 generate_document\uC758 profile_path\uB85C \uB118\uAE30\uBA74 \uC6D0\uBCF8 \uBB38\uC11C \uC5C6\uC774 \uAC19\uC740 \uD45C \uC11C\uC2DD\uC744 \uC7AC\uD604\uD569\uB2C8\uB2E4 \u2014 "\uC774 \uBB38\uC11C \uD45C \uC11C\uC2DD \uADF8\uB300\uB85C \uB9CC\uB4E4\uC5B4\uC918" \uC6CC\uD06C\uD50C\uB85C\uC758 1\uB2E8\uACC4.',
@@ -670,10 +860,10 @@ server.tool(
   },
   async ({ hwpx_path, output_path }) => {
     try {
+      const out = safeOutputPath(output_path, PROFILE_EXTENSIONS);
       const { buffer } = readValidatedFile(hwpx_path);
-      const { hwpxToProfile } = await import("./-LE4RLXVA.js");
+      const { hwpxToProfile } = await import("./-SXQIZHYA.js");
       const profile = await hwpxToProfile(buffer);
-      const out = resolve(output_path);
       mkdirSync(dirname(out), { recursive: true });
       writeFileSync(out, JSON.stringify(profile, null, 2));
       return {
@@ -682,7 +872,7 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
@@ -755,11 +945,11 @@ server.tool(
       }
       let profile;
       if (profile_path) {
-        const { parseFormatProfileJson } = await import("./profile-io-SLN4P76T.js");
-        profile = parseFormatProfileJson(readFileSync(resolve(profile_path), "utf-8"));
+        const { parseFormatProfileJson } = await import("./profile-io-TWHDIVPL.js");
+        profile = parseFormatProfileJson(readFileSync(safePath(profile_path, PROFILE_EXTENSIONS), "utf-8"));
       }
+      const out = safeOutputPath(output_path, /* @__PURE__ */ new Set([".hwpx"]));
       const buf = await markdownToHwpx(markdown, gongmun || profile ? { ...gongmun ? { gongmun } : {}, ...profile ? { profile } : {} } : void 0);
-      const out = resolve(output_path);
       mkdirSync(dirname(out), { recursive: true });
       writeFileSync(out, Buffer.from(buf));
       const mode = gongmun ? `\uACF5\uBB38\uC11C:${gongmun.preset}` : "\uBC94\uC6A9";
@@ -775,18 +965,38 @@ server.tool(
       };
     } catch (err) {
       return {
-        content: [{ type: "text", text: `\uC624\uB958: ${sanitizeError(err)}` }],
+        content: [{ type: "text", text: `\uC624\uB958: ${describeError(err)}` }],
         isError: true
       };
     }
   }
 );
-async function main() {
+var serverStarted = false;
+async function startMcpServer() {
+  if (serverStarted) return;
+  serverStarted = true;
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-main().catch((err) => {
+var autoStart = true;
+try {
+  const entry = process.argv[1];
+  if (entry && pathToFileURL(realpathSync(entry)).href !== import.meta.url) autoStart = false;
+} catch {
+}
+if (autoStart) startMcpServer().catch((err) => {
   console.error(err);
   process.exit(1);
 });
+export {
+  ALLOWED_EXTENSIONS,
+  IMAGE_EXTENSIONS,
+  PROFILE_EXTENSIONS,
+  buildFillInputs,
+  capResponseText,
+  describeError,
+  safeOutputPath,
+  safePath,
+  startMcpServer
+};
 //# sourceMappingURL=mcp.js.map