@bill_nee/dwg-reader 1.4.0 → 1.5.0

package/README.md

@@ -1,18 +1,42 @@
 # @bill_nee/dwg-reader
 
-DSH（DeepSeek Harness）插件：可直接读取 AutoCAD DWG 格式图纸，无需安装 AutoCAD。
+DSH（DeepSeek Harness）插件：直接读取 DWG/DXF 图纸、PDF 与图片/截屏，无需安装 AutoCAD、Tesseract 等外部软件。
 
-基于 [libredwg-web](https://github.com/mlightcad/libredwg-web) 0.8.2 WASM 编译，在浏览器/Node 环境中解析 DWG 文件，返回图层、实体、版本、编码、图幅等信息，并可导出 SVG 预览。
+基于 [libredwg-web](https://github.com/mlightcad/libredwg-web) 0.8.2 WASM 解析 DWG；DXF 经 Python ezdxf 桥接；PDF 用 pdf-parse；图片 OCR 使用内置 **tesseract.js（WASM）**，语言包可指向本地 tessdata，也可按需联网下载，支持 Tesseract 全量语言（100+ 种）。
 
 ## 安装
 
 在 DSH 工作台或终端执行：
 
 ```powershell
-dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0
+dsh plugin --profile desktop add @bill_nee/dwg-reader@1.5.0
 ```
 
-安装后在 DSH 工作台插件管理中启用插件，即可使用 `read_dwg` 工具读取 DWG 图纸。
+安装后在 DSH 工作台插件管理中启用插件，即可使用 `read_dwg`、`read_dxf`、`read_pdf`、`ocr_image` 四个工具（`read_image` 为 DSH 内置看图工具，本插件用 `ocr_image` 与其并存，避免同名冲突）。
+
+## 工具与参数
+
+| 工具 | 说明 |
+|------|------|
+| `read_dwg` | 解析 DWG：版本/代码页/图层/块/实体统计与明细，可导出 SVG 预览 |
+| `read_dxf` | 解析 DXF（ezdxf 桥接）：版本、图层、块、实体统计与明细 |
+| `read_pdf` | 解析 PDF：页数、元数据、可选全文文本 |
+| `ocr_image` | 图片/截屏 OCR：格式、像素尺寸、颜色模式 + 识别文字（PNG/JPEG/WebP/BMP/GIF/TIFF） |
+
+`ocr_image` 关键参数：
+
+```json
+{
+  "file_path": "F:\\HAYNESS 工作区1\\测试用资源\\截屏.png",
+  "ocr": true,
+  "lang": "chi_sim+eng",
+  "tessdata_prefix": "D:\\Tools\\Tesseract-OCR\\tessdata"
+}
+```
+
+- `lang`：Tesseract 语言码，`+` 或逗号连接，默认 `chi_sim+eng`；如 `eng`、`chi_tra`、`jpn`、`kor`、`deu`、`fra`、`rus`、`spa`、`ara`、`vie`、`tha` 等。
+- `tessdata_prefix`：本地 traineddata 目录。提供后只读本地语言包、不联网；目录缺包会报错并列出缺项。
+- 未提供 `tessdata_prefix` 时，依次探测 `TESSDATA_PREFIX` 环境变量、`D:\Tools\Tesseract-OCR\tessdata`、`C:\Program Files\Tesseract-OCR\tessdata`、`/usr/share/tesseract-ocr/4.00/tessdata` 等常见目录；均未命中才联网下载并缓存到系统临时目录。
 
 ## 主要能力
 
@@ -21,16 +45,15 @@ dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0
 | 读取 DWG | 支持 AutoCAD R14~R2018 等常见版本（AC1015~AC1032） |
 | 图层信息 | 返回所有图层名称、颜色、冻结/关闭/锁定状态 |
 | 实体统计 | 返回实体总数及按类型（LINE/TEXT/INSERT/HATCH/DIMENSION 等）分类统计 |
-| 图纸版本 | 返回 ACADVER、版本号、版本描述（如 r2018/AC1032/AutoCAD Release 2018） |
-| 代码页 | 返回 DWG 代码页（如 CP_ANSI_936） |
+| INSERT 明细 | 返回块名、插入点、旋转、缩放及块属性（tag/text/value） |
+| 图纸版本 | 返回 ACADVER、版本号、版本描述（如 r2007/AC1021） |
 | 图幅信息 | 返回 EXTMIN/EXTMAX 边界框 |
 | 导出 SVG | 可将 DWG 内容导出为 SVG 预览文件到指定路径 |
-| 错误处理 | 对无效/损坏/非 DWG 文件给出明确错误提示 |
+| 内置 OCR | tesseract.js WASM，无需安装 Tesseract 可执行文件；多语言、可离线 |
+| 错误处理 | 对无效/损坏/非目标格式文件给出明确错误提示 |
 
 ## 使用示例
 
-在 DSH 工作台调用 `read_dwg` 工具：
-
 ```json
 {
   "file_path": "E:\\2026 工程资料\\16 天喔蜜饯工厂\\03 CAD DESIGN\\02 HVAC DESIGN PLAN.dwg",
@@ -41,41 +64,19 @@ dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0
 }
 ```
 
-返回示例：
-
-```json
-{
-  "file_path": "E:\\...\\02 HVAC DESIGN PLAN.dwg",
-  "file_size": 123456,
-  "version": { "type": "r2018", "hdr": "AC1032", "description": "AutoCAD Release 2018", "version": 33 },
-  "codepage": 39,
-  "codepageName": "CP_ANSI_936",
-  "layer_count": 126,
-  "entity_count": 1514,
-  "unknown_entity_count": 0,
-  "extents": { "min": { "x": 0, "y": 0, "z": 0 }, "max": { "x": 266000, "y": 286000, "z": 0 } },
-  "layers": [ { "name": "HEPA BOX", "colorIndex": 5, ... }, ... ],
-  "entities": [
-    { "type": "INSERT", "handle": "...", "layer": "HEPA BOX", "blockName": "...", ... },
-    ...
-  ],
-  "svg_path": "F:\\HAYNESS 工作区1\\hvac-plan.svg"
-}
-```
-
 ## 测试实例
 
-已对真实工程图纸进行验证：
-
-- **天喔蜜饯工厂暖通图纸**（r2018/AC1032）：1514 个实体，126 个图层，其中高效送风口（HEPA BOX 图层）108 个，方形散流器 18 个，射流空调 5 个。
-- **植本清源空调设备图**（r2007/AC1021）：1762 个实体，14 个图层。
+- **天喔蜜饯工厂暖通图纸**（r2018/AC1032）：1514 个实体、126 个图层。
+- **植本清源空调设备图**（r2007/AC1021）：1762 个实体、14 个图层。
+- **截屏 OCR**：本地 tessdata（chi_sim+eng）约 4 秒识别 4500+ 字符；`ocr=false` 仅解析尺寸不识别。
 - **无效/损坏文件**：返回明确错误，不崩溃。
 
 ## 文件结构
 
 ```
 dwg-reader-plugin/
-├── lib/index.js          # 插件入口，注册 read_dwg 工具
+├── lib/index.js          # 插件入口，注册 read_dwg / read_dxf / read_pdf / ocr_image
+├── scripts/read_dxf.py   # DXF 解析桥接（ezdxf）
 ├── cordis.patch.yml      # DSH bundle 插件清单
 ├── package.json          # npm 包清单
 ├── LICENSE               # GPL-3.0-only
@@ -90,10 +91,10 @@ dwg-reader-plugin/
 
 ## 许可
 
-GPL-3.0-only。依赖 libredwg-web 同样为 GPL，公开分发请保留 LICENSE 并提供对应源码。
+GPL-3.0-only。依赖 libredwg-web 为 GPL，tesseract.js 为 Apache-2.0；公开分发请保留 LICENSE 并提供对应源码。
 
 ## 安装路径
 
-- npm 公开包：`@bill_nee/dwg-reader@1.1.0`
-- 安装命令：`dsh plugin --profile desktop add @bill_nee/dwg-reader@1.1.0`
+- npm 公开包：`@bill_nee/dwg-reader@1.5.0`
+- 安装命令：`dsh plugin --profile desktop add @bill_nee/dwg-reader@1.5.0`
 - GitHub 源码：https://github.com/NIDEXIANG/dwg-reader-plugin-20261029

package/lib/index.js

@@ -1,5 +1,8 @@
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { PDFParse } from "pdf-parse";
 import { LibreDwg, Dwg_File_Type, DwgCodePage } from "../vendor/libredwg-web/lib/index.js";
 
@@ -8,8 +11,8 @@ const MAX_DWG_BYTES = 512 * 1024 * 1024; // 512 MB 上限，超大图纸会先
 const MAX_ENTITY_DETAIL = 2000;
 const PYTHON_EXE = "D:\\dsh-home\\dsh-runtimes\\dsh-primary-runtime\\dependencies\\python\\python.exe";
 const DXF_SCRIPT = fileURLToPath(new URL("../scripts/read_dxf.py", import.meta.url));
-const OCR_SCRIPT = fileURLToPath(new URL("../scripts/ocr_image.py", import.meta.url));
 const MAX_PDF_BYTES = 100 * 1024 * 1024; // 100 MB PDF 上限
+const OCR_TIMEOUT_MS = 180000; // OCR 单张图片 180 秒上限
 
 let libreDwgPromise;
 
@@ -581,12 +584,262 @@ export function apply(ctx, config) {
   };
 }
 
+// ---------------------------------------------------------------------------
+// ocr_image：图片头解析 + 内置 tesseract.js（WASM）OCR
+// 不依赖外部 Tesseract 可执行文件或 Pillow；语言包可用 tessdata_prefix 指向本地目录，
+// 缺省时依次探测常见 tessdata 目录，仍未命中则按需从 CDN 下载并缓存。
+// ---------------------------------------------------------------------------
+
+const COMMON_TESSDATA_DIRS = [
+  process.env.TESSDATA_PREFIX,
+  "D:\\Tools\\Tesseract-OCR\\tessdata",
+  "C:\\Program Files\\Tesseract-OCR\\tessdata",
+  "/usr/share/tesseract-ocr/4.00/tessdata",
+  "/usr/share/tessdata",
+  "/opt/homebrew/share/tessdata",
+].filter(Boolean);
+
+function be4(bytes, offset) {
+  return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+}
+function be2(bytes, offset) {
+  return (bytes[offset] << 8) | bytes[offset + 1];
+}
+function le4(bytes, offset) {
+  return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)) >>> 0;
+}
+function le2(bytes, offset) {
+  return bytes[offset] | (bytes[offset + 1] << 8);
+}
+
+/** 从文件头解析图片格式与像素尺寸；无法识别时返回 null。 */
+function parseImageInfo(bytes) {
+  if (!bytes || bytes.length < 12) return null;
+  // PNG
+  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+    const colorType = bytes[25];
+    const mode = { 0: "GRAY", 2: "RGB", 3: "PALETTE", 4: "GRAY+ALPHA", 6: "RGBA" }[colorType] ?? null;
+    return { format: "PNG", width: be4(bytes, 16) || null, height: be4(bytes, 20) || null, mode };
+  }
+  // JPEG
+  if (bytes[0] === 0xff && bytes[1] === 0xd8) {
+    let i = 2;
+    while (i + 10 < bytes.length) {
+      if (bytes[i] !== 0xff) {
+        i += 1;
+        continue;
+      }
+      const marker = bytes[i + 1];
+      if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+        i += 2;
+        continue;
+      }
+      if (marker === 0xd9) break;
+      const segLen = be2(bytes, i + 2);
+      if (segLen < 2) break;
+      const isSof = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+      if (isSof) {
+        const comps = bytes[i + 9];
+        const mode = comps === 1 ? "GRAY" : comps === 3 ? "RGB" : comps === 4 ? "CMYK" : null;
+        return { format: "JPEG", width: be2(bytes, i + 7) || null, height: be2(bytes, i + 5) || null, mode };
+      }
+      i += 2 + segLen;
+    }
+    return { format: "JPEG", width: null, height: null, mode: null };
+  }
+  // GIF
+  if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46) {
+    return { format: "GIF", width: le2(bytes, 6) || null, height: le2(bytes, 8) || null, mode: null };
+  }
+  // BMP
+  if (bytes[0] === 0x42 && bytes[1] === 0x4d) {
+    return { format: "BMP", width: Math.abs(le4(bytes, 18)) || null, height: Math.abs(le4(bytes, 22)) || null, mode: null };
+  }
+  // WEBP
+  if (
+    bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+    bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50
+  ) {
+    const chunk = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+    if (chunk === "VP8X") {
+      return {
+        format: "WEBP",
+        width: (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)) + 1,
+        height: (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)) + 1,
+        mode: null,
+      };
+    }
+    if (chunk === "VP8L") {
+      const bits = (bytes[21] | (bytes[22] << 8) | (bytes[23] << 16) | (bytes[24] << 24)) >>> 0;
+      return { format: "WEBP", width: (bits & 0x3fff) + 1, height: ((bits >>> 14) & 0x3fff) + 1, mode: null };
+    }
+    if (chunk === "VP8 ") {
+      return { format: "WEBP", width: le2(bytes, 26) & 0x3fff, height: le2(bytes, 28) & 0x3fff, mode: null };
+    }
+    return { format: "WEBP", width: null, height: null, mode: null };
+  }
+  // TIFF（只读取第一个 IFD 的宽高标签）
+  if ((bytes[0] === 0x49 && bytes[1] === 0x49) || (bytes[0] === 0x4d && bytes[1] === 0x4d)) {
+    const little = bytes[0] === 0x49;
+    const u2 = (o) => (little ? le2(bytes, o) : be2(bytes, o));
+    const u4 = (o) => (little ? le4(bytes, o) : be4(bytes, o));
+    let width = null;
+    let height = null;
+    try {
+      const ifd = u4(4);
+      const count = u2(ifd);
+      for (let k = 0; k < Math.min(count, 256); k += 1) {
+        const entry = ifd + 2 + k * 12;
+        const tag = u2(entry);
+        const type = u2(entry + 2);
+        const valueOffset = entry + 8;
+        if (tag === 256) width = type === 3 ? u2(valueOffset) : u4(valueOffset);
+        else if (tag === 257) height = type === 3 ? u2(valueOffset) : u4(valueOffset);
+      }
+    } catch {
+      /* 无法解析时保留 null */
+    }
+    return { format: "TIFF", width: width || null, height: height || null, mode: null };
+  }
+  return null;
+}
+
+function checkTessdataDir(dir, codes) {
+  if (!dir || !existsSync(dir)) return { dir, missing: codes };
+  const missing = codes.filter((code) => {
+    try {
+      return !existsSync(join(dir, `${code}.traineddata`)) && !existsSync(join(dir, `${code}.traineddata.gz`));
+    } catch {
+      return true;
+    }
+  });
+  return { dir, missing };
+}
+
+/** 解析语言包目录：优先显式 tessdata_prefix（缺失即报错），否则探测常见目录，最后才联网。 */
+function resolveTessdataDir(codes, explicitDir) {
+  if (explicitDir) {
+    if (!existsSync(explicitDir)) {
+      throw new Error(`tessdata_prefix 目录不存在: ${explicitDir}`);
+    }
+    const checked = checkTessdataDir(explicitDir, codes);
+    if (checked.missing.length) {
+      throw new Error(
+        `tessdata_prefix 缺少语言包: ${checked.missing.map((c) => `${c}.traineddata`).join("、")}（目录 ${explicitDir}）`
+      );
+    }
+    return explicitDir;
+  }
+  for (const dir of COMMON_TESSDATA_DIRS) {
+    const checked = checkTessdataDir(dir, codes);
+    if (checked.dir && checked.missing.length === 0) return checked.dir;
+  }
+  return null;
+}
+
+let ocrWorkerPromise = null;
+let ocrWorkerKey = null;
+let ocrWorkerLangs = "";
+
+async function disposeOcrWorker() {
+  const pending = ocrWorkerPromise;
+  ocrWorkerPromise = null;
+  ocrWorkerKey = null;
+  ocrWorkerLangs = "";
+  if (!pending) return;
+  try {
+    const worker = await pending;
+    await worker.terminate();
+  } catch {
+    /* 忽略清理失败 */
+  }
+}
+
+/** 复用单个 OCR worker；语言变化时 reinitialize。 */
+async function getOcrWorker(codes, key, options) {
+  const joined = codes.join("+");
+  if (ocrWorkerPromise !== null && ocrWorkerKey === key) {
+    const worker = await ocrWorkerPromise;
+    if (ocrWorkerLangs !== joined) {
+      await worker.reinitialize(codes, 1);
+      ocrWorkerLangs = joined;
+    }
+    return worker;
+  }
+  await disposeOcrWorker();
+  ocrWorkerKey = key;
+  ocrWorkerLangs = joined;
+  ocrWorkerPromise = (async () => {
+    const { createWorker } = await import("tesseract.js");
+    return createWorker(codes, 1, options);
+  })();
+  return ocrWorkerPromise;
+}
+
+function raceWithAbort(promise, exec, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (exec.signal) exec.signal.removeEventListener("abort", onAbort);
+      fn(value);
+    };
+    const timer = setTimeout(
+      () => finish(reject, new Error(`OCR 超时（超过 ${Math.round(timeoutMs / 1000)} 秒）`)),
+      timeoutMs
+    );
+    const onAbort = () => finish(reject, exec.signal.reason ?? new Error("aborted"));
+    if (exec.signal) {
+      if (exec.signal.aborted) {
+        onAbort();
+        return;
+      }
+      exec.signal.addEventListener("abort", onAbort);
+    }
+    promise.then((v) => finish(resolve, v), (e) => finish(reject, e));
+  });
+}
+
+async function runOcr(imagePath, codes, tessdataParam, exec) {
+  const localDir = resolveTessdataDir(codes, tessdataParam);
+  const options = localDir
+    ? { langPath: localDir, gzip: false, cacheMethod: "none" }
+    : { cachePath: join(tmpdir(), "dwg-reader-ocr-cache"), gzip: true };
+  const key = localDir ? `local:${localDir}` : "cdn";
+  const worker = await getOcrWorker(codes, key, options);
+  const started = Date.now();
+  const result = await raceWithAbort(worker.recognize(imagePath), exec, OCR_TIMEOUT_MS);
+  const text = String(result?.data?.text ?? "").replace(/\r\n/g, "\n").trim();
+  return {
+    text,
+    source: localDir ? "local" : "download",
+    langPath: localDir ?? null,
+    elapsedMs: Date.now() - started,
+  };
+}
+
+function splitLangs(lang) {
+  const raw = typeof lang === "string" && lang.trim() ? lang : "chi_sim+eng";
+  const codes = raw.split(/[+,]/).map((s) => s.trim()).filter(Boolean);
+  if (!codes.length) return ["chi_sim", "eng"];
+  for (const code of codes) {
+    if (!/^[a-z0-9_]+$/i.test(code)) {
+      throw new Error(`invalid arguments: "lang" 含非法语言码 "${code}"（应为 chi_sim、eng、jpn 等）`);
+    }
+  }
+  return codes;
+}
+
 function buildReadImageTool(ctx) {
   return {
-    name: "read_image",
+    name: "ocr_image",
     description:
-      "读取图片/截屏文件（尺寸、格式、元数据 + Tesseract OCR 文字提取，无需安装图片查看软件）。" +
-      "支持 PNG/JPEG/WebP/BMP/TIFF；OCR 语言为简体中文+英文。",
+      "对图片/截屏做 OCR 文字提取（返回格式、像素尺寸、颜色模式与识别文字；不返回图片本体——看图请用内置 read_image）。" +
+      "无需安装 Tesseract 或图片查看软件，内置 tesseract.js WASM。支持 PNG/JPEG/WebP/BMP/GIF/TIFF；" +
+      "支持 Tesseract 全部语言（lang 参数，默认 chi_sim+eng），可用 tessdata_prefix 指向本地 traineddata 目录离线使用，" +
+      "未提供时自动探测常见目录，仍无则联网下载并缓存。",
     parameters: {
       type: "object",
       additionalProperties: true,
@@ -599,9 +852,15 @@ function buildReadImageTool(ctx) {
           type: "boolean",
           description: "是否执行 OCR 文字提取（默认 true）。",
         },
+        lang: {
+          type: "string",
+          description:
+            "OCR 语言码，+ 或逗号连接多个（默认 chi_sim+eng；支持 eng、chi_tra、jpn、kor、deu、fra、rus、spa、ita、por、ara、vie、tha、hin 等 Tesseract 全量语言）。",
+        },
         tessdata_prefix: {
           type: "string",
-          description: "Tesseract tessdata 目录（可选；缺省使用系统默认）。",
+          description:
+            "本地 traineddata 目录（可选；提供后只读本地语言包、不联网。目录内需有 <语言码>.traineddata 或 .traineddata.gz；缺包会报错并列出缺项）。",
         },
       },
       required: ["file_path"],
@@ -615,31 +874,36 @@ function buildReadImageTool(ctx) {
           fileName: { type: "string", description: "文件名。" },
           fileSizeBytes: { type: "integer", description: "文件字节数。" },
           format: { type: "string", description: "图片格式（如 PNG/JPEG）。" },
-          width: { type: "integer", description: "图片宽度（像素）。" },
-          height: { type: "integer", description: "图片高度（像素）。" },
-          mode: { type: "string", description: "颜色模式（如 RGB/RGBA）。" },
+          width: { oneOf: [{ type: "integer" }, { type: "null" }], description: "图片宽度（像素）。" },
+          height: { oneOf: [{ type: "integer" }, { type: "null" }], description: "图片高度（像素）。" },
+          mode: { oneOf: [{ type: "string" }, { type: "null" }], description: "颜色模式（如 RGB/RGBA）。" },
+          lang: { type: "string", description: "实际使用的 OCR 语言码。" },
+          tessdataSource: { type: "string", description: "语言包来源：local（本地目录）/download（联网下载）/none（未启用 OCR）。" },
           ocrText: { type: "string", description: "OCR 提取的文字（可能为空）。" },
-          ocrError: { type: "string", description: "OCR 错误信息；成功时为 null。" },
-          error: { type: "string", description: "错误信息；成功时为 null。" },
+          ocrError: { oneOf: [{ type: "string" }, { type: "null" }], description: "OCR 错误信息；成功时为 null。" },
+          ocrElapsedMs: { type: "integer", description: "OCR 耗时（毫秒）。" },
         },
       },
       render: (args, value) => {
         const lines = [];
         lines.push(`<path>${value.path}</path>`);
         lines.push(`<type>image</type>`);
-        if (value.error) {
-          lines.push(`<content>读取图片失败：${value.error}</content>`);
-          return [{ type: "text", text: lines.join("\n") }];
-        }
         const sizeKb = (value.fileSizeBytes / 1024).toFixed(1);
         lines.push(`<content>已解析图片：${value.fileName}（${sizeKb} KB）`);
-        lines.push(`格式：${value.format}；尺寸：${value.width}×${value.height}；模式：${value.mode}`);
+        const dims = value.width != null && value.height != null ? `${value.width}×${value.height}` : "未知";
+        lines.push(`格式：${value.format}；尺寸：${dims}；模式：${value.mode ?? "未知"}`);
+        if (value.ocrElapsedMs > 0) {
+          const source = value.tessdataSource === "local" ? "本地语言包" : "联网下载语言包";
+          lines.push(`OCR 语言：${value.lang}（${source}，耗时 ${(value.ocrElapsedMs / 1000).toFixed(1)} 秒）`);
+        } else {
+          lines.push("OCR：未启用");
+        }
         if (value.ocrError) lines.push(`OCR 错误：${value.ocrError}`);
         if (value.ocrText) {
           const preview = value.ocrText.slice(0, 300);
           lines.push(`OCR 文字（${value.ocrText.length} 字符）：${preview}${value.ocrText.length > 300 ? "…" : ""}`);
         } else if (!value.ocrError) {
-          lines.push("OCR 文字：无（未检测到可识别文字或 OCR 未启用）");
+          lines.push("OCR 文字：无（未识别出文字）");
         }
         lines.push(`</content>`);
         return [{ type: "text", text: lines.join("\n") }];
@@ -672,9 +936,13 @@ function buildReadImageTool(ctx) {
       if (args.ocr !== undefined && typeof args.ocr !== "boolean") {
         throw new Error('invalid arguments: "ocr" must be a boolean');
       }
+      if (args.lang !== undefined && typeof args.lang !== "string") {
+        throw new Error('invalid arguments: "lang" must be a string');
+      }
       if (args.tessdata_prefix !== undefined && typeof args.tessdata_prefix !== "string") {
         throw new Error('invalid arguments: "tessdata_prefix" must be a string');
       }
+      const langCodes = splitLangs(args.lang);
 
       const resolveOptions = await sessionResolveOptions(ctx, exec);
       const target = await ctx.fs.resolve(args.file_path.trim(), resolveOptions);
@@ -688,34 +956,28 @@ function buildReadImageTool(ctx) {
         throw new Error(`cannot read "${displayPath}": not a regular file`);
       }
 
-      const pythonArgs = [
-        OCR_SCRIPT,
-        args.file_path.trim(),
-        "D:\\Tools\\Tesseract-OCR\\tesseract.exe",
-      ];
-
-      const result = await new Promise((resolve, reject) => {
-        const proc = spawn(PYTHON_EXE, pythonArgs, { stdio: ["pipe", "pipe", "pipe"] });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (d) => (stdout += d.toString()));
-        proc.stderr.on("data", (d) => (stderr += d.toString()));
-        proc.on("close", (code) => {
-          if (code !== 0) {
-            reject(new Error(`Python 进程退出码 ${code}: ${stderr || stdout}`));
-            return;
-          }
-          try {
-            resolve(JSON.parse(stdout));
-          } catch (err) {
-            reject(new Error(`OCR 结果解析失败: ${err.message}; stdout=${stdout.slice(0, 200)}`));
-          }
-        });
-        proc.on("error", (err) => reject(new Error(`无法启动 Python 进程: ${err.message}`)));
-      });
+      // 先读文件头判断格式与尺寸（最多 2 MB，足够覆盖 JPEG 的 SOF 段）
+      const header = await ctx.fs.readBytes(target, exec.signal, 2 * 1024 * 1024);
+      const parsed = parseImageInfo(header);
+      if (!parsed) {
+        throw new Error(`cannot read "${displayPath}": 无法识别的图片格式（支持 PNG/JPEG/WebP/BMP/GIF/TIFF）`);
+      }
 
-      if (result.error) {
-        throw new Error(`cannot read "${displayPath}": ${result.error}`);
+      let ocrText = "";
+      let ocrError = null;
+      let tessdataSource = "none";
+      let ocrElapsedMs = 0;
+      if (args.ocr !== false) {
+        try {
+          const ocr = await runOcr(args.file_path.trim(), langCodes, args.tessdata_prefix, exec);
+          ocrText = ocr.text;
+          tessdataSource = ocr.source;
+          ocrElapsedMs = ocr.elapsedMs;
+        } catch (error) {
+          ocrError = error?.message ?? String(error);
+          // OCR 失败或超时后 worker 可能仍卡在识别中，销毁以便下次重建
+          await disposeOcrWorker();
+        }
       }
 
       ctx.emit("fs/observed", target, { kind: "present", version: info.version }, exec);
@@ -723,13 +985,16 @@ function buildReadImageTool(ctx) {
       return toJson({
         path: displayPath,
         fileName: displayPath.split(/[\\/]/).pop(),
-        fileSizeBytes: result.fileSizeBytes ?? info.size !== undefined ? info.size : 0,
-        format: result.format ?? "",
-        width: result.width ?? null,
-        height: result.height ?? null,
-        mode: result.mode ?? null,
-        ocrText: result.ocrText ?? "",
-        ocrError: result.ocrError ?? null,
+        fileSizeBytes: info.size !== undefined ? info.size : 0,
+        format: parsed.format,
+        width: parsed.width,
+        height: parsed.height,
+        mode: parsed.mode,
+        lang: langCodes.join("+"),
+        tessdataSource,
+        ocrText,
+        ocrError,
+        ocrElapsedMs,
       });
     },
   };
@@ -868,8 +1133,13 @@ function buildReadPdfTool(ctx) {
       let metadata = {};
       try {
         const infoResult = await parser.getInfo();
-        pageCount = infoResult.info?.Pages != null ? Number(infoResult.info.Pages) : 0;
-        metadata = infoResult.metadata ?? {};
+        pageCount =
+          infoResult.total != null
+            ? Number(infoResult.total)
+            : infoResult.info?.Pages != null
+              ? Number(infoResult.info.Pages)
+              : 0;
+        metadata = infoResult.metadata ?? infoResult.info ?? {};
         if (args.extract_text !== false) {
           const textResult = await parser.getText();
           text = textResult?.text ?? "";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bill_nee/dwg-reader",
-  "version": "1.4.0",
-  "description": "直接读取 AutoCAD DWG/DXF、PDF 与图片/截屏的 DSH 插件（DWG 基于 libredwg-web 0.8.2 WASM，DXF 基于 Python ezdxf 桥接，PDF 基于 pdf-parse，图片基于 Pillow+Tesseract OCR，GPL-3.0）。",
+  "version": "1.5.0",
+  "description": "直接读取 AutoCAD DWG/DXF、PDF 与图片/截屏的 DSH 插件（DWG 基于 libredwg-web 0.8.2 WASM，DXF 基于 Python ezdxf 桥接，PDF 基于 pdf-parse，图片基于内置 tesseract.js WASM OCR，支持本地 tessdata 多语言，GPL-3.0）。",
   "license": "GPL-3.0-only",
   "author": "MEB 工程造价项目助手 <meb@example.com>",
   "repository": {
@@ -42,6 +42,7 @@
     }
   },
   "dependencies": {
-    "pdf-parse": "^2.4.5"
+    "pdf-parse": "^2.4.5",
+    "tesseract.js": "^7.0.0"
   }
 }

package/scripts/ocr_image.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-"""对图片进行 OCR 文字提取（供 DSH dwg-reader 插件调用，直接调用 tesseract 命令行）。"""
-import sys
-import json
-import os
-import subprocess
-import tempfile
-
-IMAGE_PATH = sys.argv[1] if len(sys.argv) > 1 else None
-TESSERACT_CMD = sys.argv[2] if len(sys.argv) > 2 else r"D:\Tools\Tesseract-OCR\tesseract.exe"
-
-
-def main():
-    if not IMAGE_PATH or not os.path.exists(IMAGE_PATH):
-        print(json.dumps({"error": f"文件不存在: {IMAGE_PATH}"}))
-        sys.exit(1)
-
-    try:
-        from PIL import Image
-    except ImportError as exc:
-        print(json.dumps({"error": f"Pillow 未安装: {exc}"}))
-        sys.exit(1)
-
-    try:
-        image = Image.open(IMAGE_PATH)
-    except Exception as exc:
-        print(json.dumps({"error": f"无法打开图片: {exc}"}))
-        sys.exit(1)
-
-    width, height = image.size
-    fmt = image.format
-    mode = image.mode
-
-    # 调用 tesseract 命令行做 OCR
-    ocr_text = ""
-    ocr_error = None
-    try:
-        with tempfile.TemporaryDirectory() as tmpdir:
-            out_base = os.path.join(tmpdir, "ocr_out")
-            cmd = [TESSERACT_CMD, IMAGE_PATH, out_base, "-l", "chi_sim+eng"]
-            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
-            if proc.returncode != 0:
-                ocr_error = proc.stderr.strip() or f"tesseract 退出码 {proc.returncode}"
-            else:
-                out_txt = out_base + ".txt"
-                if os.path.exists(out_txt):
-                    with open(out_txt, "r", encoding="utf-8", errors="replace") as f:
-                        ocr_text = f.read().strip()
-    except Exception as exc:
-        ocr_error = str(exc)
-
-    result = {
-        "path": os.path.abspath(IMAGE_PATH),
-        "fileName": os.path.basename(IMAGE_PATH),
-        "fileSizeBytes": os.path.getsize(IMAGE_PATH),
-        "format": fmt,
-        "width": width,
-        "height": height,
-        "mode": mode,
-        "ocrText": ocr_text,
-        "ocrError": ocr_error,
-    }
-    # Windows 控制台默认 GBK，改为 UTF-8 输出到 stdout.buffer 避免编码错误
-    sys.stdout.buffer.write(json.dumps(result, ensure_ascii=False).encode("utf-8"))
-    sys.stdout.buffer.write(b"\n")
-    sys.stdout.buffer.flush()
-
-
-if __name__ == "__main__":
-    main()