dsh-origin-bridge 0.4.5 → 0.4.7

package/originlab.py

@@ -24,6 +24,7 @@ import asciiio
 import binio
 
 MISSING_SENTINEL = -1.23456789e-300
+_INF = float("inf")
 # Verified against OriginPro 2024 SR1 by exporting each code and looking at the
 # image: 200 line, 201 symbol, 202 line+symbol, 203 column.
 PLOT_CODES = {"line": 200, "scatter": 201, "line_symbol": 202, "column": 203}
@@ -396,13 +397,20 @@ def _graph_of(op, ref):
 
 
 def sanitize(obj):
-    """Origin encodes missing numbers as -1.23456789e-300; never leak that upstream."""
+    """Origin encodes missing numbers as -1.23456789e-300; never leak that upstream.
+
+    +-Infinity belongs here too. json.dumps happily writes a bare ``Infinity``,
+    which is not valid JSON, so a single overflowed fit parameter or a ``1e400``
+    read out of a file would make the whole tool response unparseable for a strict
+    client — the failure looks like "the bridge is broken", not like one bad number.
+    """
     if isinstance(obj, dict):
         return {k: sanitize(v) for k, v in obj.items()}
     if isinstance(obj, (list, tuple)):
         return [sanitize(v) for v in obj]
-    if isinstance(obj, float) and (obj != obj or abs(obj - MISSING_SENTINEL) < 1e-310):
-        return None
+    if isinstance(obj, float):
+        if obj != obj or obj in (_INF, -_INF) or abs(obj - MISSING_SENTINEL) < 1e-310:
+            return None
     return obj
 
 
@@ -510,6 +518,127 @@ def _verify_file(path, must_be_image=True, min_bytes=1024):
     return {"ok": ok, "path": path, "bytes": size, "dimensions": dims, "head": head[:8].hex()}
 
 
+# Measured 2026-10-12 against the live bridge: Origin's export filter treats '#'
+# in the filename as a numbering token — asking for 100%_a#b[1].png produced
+# 100%_a1b[1].png (the '#' became "1"), while '%', '[]', spaces and 中文 survive.
+# A trailing space or dot in any component is stripped by Win32 before creation,
+# so isfile() on the literal path we asked for says False while the bytes really
+# are on disk. And a path that carries no real filename (".", "   ", ".png")
+# used to resolve into the process CWD and come back as a dotfile named ".png" —
+# littering the plugin install folder.
+_HASH_RUN = re.compile(r"#+")
+
+
+def _clean_component(part):
+    stripped = part.rstrip(" .")
+    return stripped if stripped else part
+
+
+def _norm_target(path, fmt=None):
+    """Absolute, expanduser'd, and normalised the way Windows will do it anyway."""
+    raw = str(path or "").strip()
+    if not raw:
+        return ""
+    target = os.path.abspath(os.path.expanduser(raw))
+    drive, rest = os.path.splitdrive(target)
+    target = drive + os.sep.join(_clean_component(p) for p in rest.split(os.sep))
+    base = os.path.basename(target)
+    if not base.split(".")[0].strip(" ."):
+        raise OriginError("bad_path", "路径里没有真正的文件名：%r" % path,
+                          ["给完整的文件名，例如 D:\\out\\图.png",
+                           "只想用默认目录就别传 path"])
+    if os.path.isdir(target):
+        raise OriginError("bad_path", "path 指向一个目录，不是文件：%s" % target,
+                          ["把文件名补上，例如 %s\\figure.png" % target])
+    stem, ext = os.path.splitext(base)
+    if fmt and ext.lower().lstrip(".") != fmt:
+        target = os.path.splitext(target)[0] + "." + fmt
+    return target
+
+
+def _prepare_write(target):
+    """Make the directory and refuse up front what Origin cannot write anyway."""
+    folder = os.path.dirname(target) or "."
+    try:
+        os.makedirs(folder, exist_ok=True)
+    except OSError as exc:
+        raise OriginError("bad_path", "输出目录建不出来：%s（%s）" % (folder, exc.strerror or exc),
+                          ["盘符存在吗（例如 Q: 未映射）",
+                           "网络路径要用 \\服务器\\共享\\… 且当前身份有写权限",
+                           "路径里去掉尾部空格或点，Windows 会静默截掉"])
+    if os.path.isdir(target):
+        raise OriginError("bad_path", "path 是一个目录，不是文件：%s" % target,
+                          ["把文件名补上，例如 %s\\figure.png" % target])
+    if os.path.exists(target) and not os.access(target, os.W_OK):
+        raise OriginError("target_locked", "目标文件已存在且不可写（只读或被占用）：%s" % target,
+                          ["去掉只读属性或换文件名", "文件可能正被 Origin/图片查看器占用，先关掉"])
+
+
+def _rel_note(path):
+    """A relative path resolves against the process CWD, which under dsh is the
+    plugin's own install folder — worth saying so instead of littering it."""
+    raw = str(path or "").strip()
+    if raw and not os.path.isabs(os.path.expanduser(raw)):
+        return ("path 是相对路径，已解析到进程工作目录 %s；dsh 下那是插件安装目录，"
+                "交付文件请给绝对路径" % os.path.abspath(raw))
+    return None
+
+
+def _lift_warnings(out):
+    """Nested export/project notes belong at the top of the result too.
+
+    A model reads the head of a tool result first; if Origin rewrote a filename
+    and the note only lives under out["export"]["warnings"], the delivery looks
+    clean when it is not.
+    """
+    lifted = list(out.get("warnings") or [])
+    for part in ("export", "project"):
+        sub = out.get(part) or {}
+        for note in (sub.get("warnings") or []):
+            if note not in lifted:
+                lifted.append(note)
+    if lifted:
+        out["warnings"] = lifted
+    return out
+
+
+def _written_or_mangled(target):
+    """Locate what Origin actually wrote; rename it back when its filter rewrote '#'."""
+    if os.path.isfile(target):
+        return target, None
+    folder = os.path.dirname(target) or "."
+    stem, ext = os.path.splitext(os.path.basename(target))
+    if not _HASH_RUN.search(stem):
+        return None, None
+    # Origin replaced every run of '#' with digits; turn the requested name into a
+    # pattern and accept a single unambiguous match, then rename it back.
+    pattern = []
+    i = 0
+    while i < len(stem):
+        m = _HASH_RUN.match(stem, i)
+        if m:
+            pattern.append(r"\d+")
+            i = m.end()
+        else:
+            pattern.append(re.escape(stem[i]))
+            i += 1
+    rx = re.compile("^%s%s$" % ("".join(pattern), re.escape(ext)))
+    try:
+        hits = [n for n in os.listdir(folder) if rx.match(n)]
+    except OSError:
+        hits = []
+    if len(hits) != 1:
+        return None, None
+    cand = os.path.join(folder, hits[0])
+    try:
+        os.replace(cand, target)
+        return target, ("Origin 的导出滤镜把文件名里的 # 换成了编号（实际写成 %s），已改名回你要求的路径；"
+                        "要避免就别说文件名里带 #" % hits[0])
+    except OSError as exc:
+        return cand, ("Origin 把文件名写成了 %s（# 被换成编号），改名回原路径失败：%s"
+                      % (hits[0], exc.strerror or exc))
+
+
 # ---------------------------------------------------------------- operations
 
 
@@ -540,7 +669,16 @@ def read_file(path, comment=None):
     path = os.path.abspath(os.path.expanduser(path))
     if not os.path.isfile(path):
         raise OriginError("file_not_found", "文件不存在：%s" % path)
-    if os.path.splitext(path)[1].lower() == ".bin":
+    ext = os.path.splitext(path)[1].lower()
+    if ext in (".xls", ".xlsx", ".wks"):
+        # Decoding a zip/OLE container as text "succeeds" into mojibake and then reports
+        # "只有表头？", blaming the user's file for our mistake (measured 2026-10-19).
+        raise OriginError(
+            "unsupported_file_type",
+            "%s 是二进制表格，origin_read_file 只读文本类数据" % ext,
+            ["用 origin_import 直接导入（走 Origin 原生导入）",
+             "或先在 Excel 里另存为 .csv，再用 origin_read_file 预览结构"])
+    if ext == ".bin":
         try:
             decoded = binio.read_bin(path)
         except binio.BinFormatError as exc:
@@ -560,8 +698,14 @@ def read_file(path, comment=None):
     except ValueError as exc:
         raise OriginError("parse_failed", str(exc),
                           ["确认文件里有数值行", "给 comment 指定实际的注释前缀"])
-    parsed["columns"] = [{k: v for k, v in c.items() if k != "values"}
-                         for c in parsed["columns"]]
+    # Three raw values per column: enough for the model to spot a shifted column or a
+    # column that parsed to nothing, without putting the whole dataset in context.
+    parsed["columns"] = [
+        dict({k: v for k, v in c.items() if k != "values"},
+             sample=(c.get("values") or [])[:3])
+        for c in parsed["columns"]]
+    parsed["sample_note"] = ("sample 是每列前 3 个原始值（缺值为 null），只用来抽查解析是否正确；"
+                             "完整数据用 origin_import 进 Origin")
     parsed["proof_level"] = "verified"
     return sanitize(parsed)
 
@@ -1441,18 +1585,24 @@ def export(graph, path="", fmt="png", width=1600):
         # No path is not an invitation to write into the process CWD: under dsh
         # that is the plugin's node_modules folder. Origin's User Files wins.
         folder = _safe(lambda: op.path("u"), "") or os.getcwd()
-        target_path = os.path.abspath(path or os.path.join(folder, "%s.%s" % (name, fmt)))
-        if os.path.splitext(target_path)[1].lower().lstrip(".") != fmt:
-            target_path = os.path.splitext(target_path)[0] + "." + fmt
-        os.makedirs(os.path.dirname(target_path) or ".", exist_ok=True)
+        raw_path = str(path or "").strip()
+        target_path = _norm_target(raw_path or os.path.join(folder, "%s.%s" % (name, fmt)), fmt)
+        _prepare_write(target_path)
         _safe(lambda: page.save_fig(target_path))
-        if not os.path.isfile(target_path):
+        written, note = _written_or_mangled(target_path)
+        if not written:
             raise OriginError("export_failed", "Origin 说导出了但文件不存在：%s" % target_path,
-                              ["路径必须可写且最好是 ASCII", "先 origin_inspect 确认图页非空"])
-        info = _verify_file(target_path)
+                              ["路径必须可写；UNC/未映射盘先排除",
+                               "先 origin_inspect 确认图页非空"])
+        info = _verify_file(written)
         if not info["ok"]:
             raise OriginError("export_suspect", "导出文件过小或文件头不对：%s" % info,
                               ["图页可能是空的：origin_inspect 看 plots 数"])
+        if note:
+            info["warnings"] = [note]
+        rel = _rel_note(path)
+        if rel:
+            info["warnings"] = (info.get("warnings") or []) + [rel]
         return sanitize(dict(info, channel="originpro.save_fig", graph=name))
 
     return call(run)
@@ -1463,8 +1613,8 @@ def _save_project(path=""):
     def run():
         global _project_file
         op = origin()
-        if path:
-            target = os.path.abspath(path)
+        if str(path).strip():
+            target = _norm_target(path)
         elif _project_file:
             target = _project_file
         else:
@@ -1474,7 +1624,7 @@ def _save_project(path=""):
                                   time.strftime("origin_bridge_%Y%m%d_%H%M%S.opju"))
         if not target.lower().endswith((".opju", ".opj")):
             target += ".opju"
-        os.makedirs(os.path.dirname(target) or ".", exist_ok=True)
+        _prepare_write(target)
 
         # op.save(file) is Origin's Save-As: once the project is bound to that
         # file, saving the same name again returns False without meaning failure.
@@ -1484,10 +1634,12 @@ def _save_project(path=""):
         mtime_before = os.path.getmtime(target) if os.path.isfile(target) else 0
         ok = bool(op.save()) if same_file else bool(op.save(target))
 
-        if not os.path.isfile(target):
+        written, _note = _written_or_mangled(target)
+        if not written:
             raise OriginError("save_failed", "保存工程失败：%s (ok=%s)" % (target, ok),
-                              ["确认目录可写、路径为 ASCII",
+                              ["确认目录可写；中文、空格、超长路径实测都能存，UNC/未映射盘不行",
                                "换一个不冲突的文件名，或省略 path 用自动时间戳命名"])
+        target = written
         fresh = os.path.getmtime(target) > mtime_before
         if not ok and not (same_file and not fresh):
             raise OriginError("save_failed", "保存工程失败：%s (ok=%s)" % (target, ok),
@@ -1525,12 +1677,26 @@ def open_project(path):
     def run():
         global _project_file
         op = origin()
-        if not op.open(path):
+        # Opening a project replaces every page, so every handle handed out earlier is
+        # dead — and a *refused* open can still have closed the current project. Both
+        # ways the table has to go: leaving it behind makes later calls act on dead
+        # pages, where originpro's wrapper "succeeds" and Origin quietly writes nothing
+        # (that is how three exports failed in the 1124-case run).
+        try:
+            ok = bool(op.open(path))
+        finally:
+            _handles.clear()
+            _names.clear()
+        if not ok:
+            _project_file = ""
             raise OriginError("open_failed", "Origin 拒绝打开这个工程：%s" % path,
                               ["确认文件是 .opju/.opj 且没被另一个 Origin 实例锁住",
-                               "Origin 版本低于该工程保存版本时也打不开"])
+                               "Origin 版本低于该工程保存版本时也打不开",
+                               "打开失败后旧句柄已作废，请重新 origin_inspect 看当前页面"])
         _project_file = path
-        return sanitize({"opened": path, "open_pages": [p.name for p in op.pages()]})
+        return sanitize({"opened": path, "open_pages": [p.name for p in op.pages()],
+                         "handles_reset": True,
+                         "note": "之前拿到的 ws-/gr- 句柄全部作废（工程换了页面），请用这里的页面名或重新导入"})
 
     return call(run)
 
@@ -1647,7 +1813,7 @@ def figure(source="", columns=None, x=1, y=1, plot_type="line", title="",
     out["proof_level"] = "verified" if deliver.get("image") else "readback_only"
     out["steps"] = steps
     out["duration_ms"] = int((time.time() - t0) * 1000)
-    return out
+    return _lift_warnings(out)
 
 
 # ------------------------------------------------------- matrix / 3D / heat maps
@@ -1711,22 +1877,27 @@ def matrix_plot(rows, template="heat_map", book_name="", graph_name="",
             out["export"] = _export_on_com_thread(gr, export_path)
         if project_path:
             out["project"] = _save_project(project_path)
-        return sanitize(out)
+        return sanitize(_lift_warnings(out))
 
     return call(run)
 
 
 def _export_on_com_thread(page, path):
     """export() body, for reuse inside another run() that is already on the thread."""
-    ext = os.path.splitext(path)[1].lower() or ".png"
-    target = os.path.abspath(path)
-    os.makedirs(os.path.dirname(target) or ".", exist_ok=True)
+    target = _norm_target(path)
+    if not os.path.splitext(target)[1]:
+        target += ".png"
+    ext = os.path.splitext(target)[1].lower()
+    _prepare_write(target)
     _safe(lambda: page.save_fig(target))
-    if not os.path.isfile(target):
+    written, note = _written_or_mangled(target)
+    if not written:
         raise OriginError("export_failed", "矩阵图导出没落盘：%s" % target)
-    info = _verify_file(target, must_be_image=ext in IMAGE_MAGIC)
+    info = _verify_file(written, must_be_image=ext in IMAGE_MAGIC)
     if not info["ok"]:
         raise OriginError("export_suspect", "导出文件异常：%s" % info)
+    if note:
+        info["warnings"] = [note]
     return info
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-origin-bridge",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "在对话里驱动本机 Origin / OriginPro：导入 .dat/.csv/.txt 与电化学工作站 .bin，绘图、拟合、改样式，导出图片并保存可在 Origin 里继续编辑的 .opju 工程。dsh 插件，27 个 MCP 工具。第三方工具，与 OriginLab Corporation 无关联、未获认可。",
   "license": "MIT",
   "type": "module",
@@ -14,9 +14,6 @@
   "homepage": "https://github.com/caob23/dsh-origin-bridge#readme",
   "main": "./index.js",
   "icon": "./icon.svg",
-  "dependencies": {
-    "@deepseek-ai/dsh-mcp-client": ">=0.1.0-rc.1"
-  },
   "bin": {
     "origin-bridge": "bin/origin-bridge.mjs"
   },
@@ -53,6 +50,9 @@
     "fixtures/*.txt",
     "smoke_test.py",
     "edge_checks.py",
+    "test_paths.py",
+    "test_json_safety.py",
+    "test_readfile.py",
     "test_asciiio.py",
     "test_binio.py",
     "test_lifecycle.py",
@@ -78,5 +78,13 @@
     "opju",
     "scientific-plotting",
     "electrochemistry"
-  ]
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/dsh-mcp-client": "0.2.0-rc.2 || >=0.1.0-rc.1 <1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-mcp-client": {
+      "optional": true
+    }
+  }
 }

package/requirements.txt

@@ -1,2 +1,4 @@
+# 实测环境：originpro 1.1.15 + OriginPro 2024 SR1 (10.100178) + Python 3.12
+# originpro 要求 Origin 2021+；2.x 没有验证过，暂不设上限。
 originpro>=1.1.0
 numpy>=1.24

package/server.py

@@ -20,7 +20,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import originlab  # noqa: E402
 
 SERVER_NAME = "origin-bridge"
-SERVER_VERSION = "0.4.5"
+SERVER_VERSION = "0.4.7"
 PROTOCOL = "2024-11-05"
 
 
@@ -106,7 +106,7 @@ TOOLS = [
     },
     {
         "name": "origin_read_file",
-        "description": "只解析数据文件、不碰 Origin：返回编码、分隔符、表头行数、每列长名/单位/有效行数，以及仪器参数 metadata。拿到陌生 .dat/.csv/.txt 先用它看清结构，再决定 origin_import 用哪几列。支持 #、//、!、; 注释、BOM、GBK、空格对齐、Fortran 的 1.5d+00 指数、NA/- 缺失值、Origin 三行表头（Long Name/Units/Comments），也支持电化学工作站（CH Instruments 等）导出的 txt：前面几十行参数说明会被跳进 metadata，紧贴数据的 Potential/V, Current/A 这类表头按斜杠拆出列名和单位。.bin 走另一条解析路线：返回技术标签（CV/LSV/IMP/i-t）、点数、两个 float32 数组的范围和 role_confidence。",
+        "description": "只解析数据文件、不碰 Origin：返回编码、分隔符、表头行数、每列长名/单位/有效行数，以及仪器参数 metadata。拿到陌生 .dat/.csv/.txt 先用它看清结构，再决定 origin_import 用哪几列。支持 #、//、!、; 注释、BOM、GBK、空格对齐、Fortran 的 1.5d+00 指数、NA/- 缺失值、Origin 三行表头（Long Name/Units/Comments），也支持电化学工作站（CH Instruments 等）导出的 txt：前面几十行参数说明会被跳进 metadata，紧贴数据的 Potential/V, Current/A 这类表头按斜杠拆出列名和单位。编码覆盖 UTF-8 / GBK / UTF-16（有无 BOM）/ cp1252；<0.001、2.5±0.1、25 mV、1,234.5、(500)、2.5* 这类被装饰的数值会解出来并在 warnings 里说明代入了什么。每列还带 sample（前 3 个原始值，缺值为 null），用来抽查解析对不对——完整数据仍然只进 Origin。二进制表格 .xls/.xlsx/.wks 不在它的范围内，会明确返回 unsupported_file_type，请用 origin_import。.bin 走另一条解析路线：返回技术标签（CV/LSV/IMP/i-t）、点数、两个 float32 数组的范围和 role_confidence。",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -192,13 +192,14 @@ TOOLS = [
     },
     {
         "name": "origin_export",
-        "description": "把图页导出为图片文件，并校验文件确实存在、够大、文件头正确（Origin 有静默失败的历史）。fmt: png/tif/jpg/svg/pdf/emf（tiff→tif、jpeg→jpg 会自动改写扩展名）。",
+        "description": "把图页导出为图片文件，并校验文件确实存在、够大、文件头正确（Origin 有静默失败的历史）。fmt: png/tif/jpg/svg/pdf/emf（tiff→tif、jpeg→jpg 会自动改写扩展名）。path 给绝对路径：中文、空格、长路径实测可用，未映射盘/UNC/把目录当文件名返回 bad_path，已存在但只读或被占用返回 target_locked（不覆盖）。文件名里的 # 会被 Origin 换成编号，桥认出后改名回你要的名字并在 warnings 里说明——那是成功，不是失败。",
         "inputSchema": {
             "type": "object",
             "properties": {
                 "graph": {"type": "string"},
                 "path": {"type": "string", "description": "输出文件绝对路径；省略则用图页名放到当前目录"},
-                "fmt": {"type": "string", "enum": ["png", "tif", "svg", "pdf", "emf"], "default": "png"},
+                "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
+                        "default": "png"},
                 "width": {"type": "integer", "default": 1600},
             },
         },
@@ -207,7 +208,7 @@ TOOLS = [
     },
     {
         "name": "origin_save_project",
-        "description": "保存为可在 Origin 里继续编辑的 .opju 工程文件（不是图片快照）。省略 path 会自动命名。",
+        "description": "保存为可在 Origin 里继续编辑的 .opju 工程文件（不是图片快照）。省略 path 会自动命名。path 给绝对路径，中文/空格/长路径实测可用；未映射盘、UNC、把目录当文件名一律 bad_path，不会假装存好了。",
         "inputSchema": {
             "type": "object",
             "properties": {"path": {"type": "string"}},
@@ -216,7 +217,7 @@ TOOLS = [
     },
     {
         "name": "origin_open",
-        "description": "打开已有的 .opju/.opj 工程，返回页面清单。",
+        "description": "打开已有的 .opju/.opj 工程，返回页面清单。打开会替换工程里的所有页面，所以之前拿到的 ws-/gr- 句柄全部作废（返回 handles_reset: true）——要用就用返回的页面名，或重新 origin_import/origin_plot 拿新句柄；打开失败时旧句柄同样作废。",
         "inputSchema": {
             "type": "object",
             "properties": {"path": {"type": "string"}},
@@ -235,7 +236,7 @@ TOOLS = [
     },
     {
         "name": "origin_figure",
-        "description": "主路径：一次调用完成 导入/写数 → 画图 → 轴标题 → 导出图片 → 保存可编辑 .opju。用户只想“把这份数据画成图并给我文件”时用它，不要拆成多步。返回里若有 warnings，说明图虽然画成了但可能不可读（例如线性横轴跨了几个数量级，点全挤在最左边）：把 next_actions 里的方案讲给用户让他选，不要自己擅自改轴。",
+        "description": "主路径：一次调用完成 导入/写数 → 画图 → 轴标题 → 导出图片 → 保存可编辑 .opju。用户只想“把这份数据画成图并给我文件”时用它，不要拆成多步。返回里若有 warnings，可能是两类：图不可读（例如线性横轴跨了几个数量级，点全挤在最左边）——把 next_actions 里的方案讲给用户让他选，不要自己擅自改轴；或是路径被代劳了（文件名里的 # 被 Origin 换成编号后改回、相对路径落到进程工作目录）——转达给用户即可，交付本身是成功的。",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -247,7 +248,8 @@ TOOLS = [
                 "title": {"type": "string"},
                 "x_title": {"type": "string"},
                 "y_title": {"type": "string"},
-                "fmt": {"type": "string", "enum": ["png", "tif", "svg", "pdf", "emf"], "default": "png"},
+                "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
+                        "default": "png"},
                 "width": {"type": "integer", "default": 1600},
                 "output_dir": {"type": "string", "description": "交付目录：图片 + opju 都写到这。不给则只建图、不落盘"},
                 "export_path": {"type": "string"},
@@ -417,7 +419,8 @@ TOOLS = [
                 "title": {"type": "string"},
                 "plot_type": {"type": "string", "enum": ["line", "scatter", "line_symbol", "column"]},
                 "with_legend": {"type": "boolean", "default": True},
-                "fmt": {"type": "string", "enum": ["png", "tif", "svg", "pdf", "emf"], "default": "png"},
+                "fmt": {"type": "string", "enum": ["png", "tif", "jpg", "jpeg", "svg", "pdf", "emf"],
+                        "default": "png"},
                 "width": {"type": "integer", "default": 1600},
             },
             "required": ["name"],
@@ -604,7 +607,20 @@ def main():
                          "error": {"code": -32603, "message": "internal error: %s" % exc}}
         if reply is None:
             continue
-        stdout.write((json.dumps(reply, ensure_ascii=False, default=str) + "\n").encode("utf-8"))
+        # allow_nan=False is the last line of defence. A bare Infinity/NaN in a
+        # reply is not valid JSON, so a strict client (dsh) fails to parse the
+        # *entire* result rather than one field. If anything still slips through,
+        # answer with a clean JSON-RPC error instead of either killing the session
+        # or writing bytes no client can read.
+        try:
+            line = json.dumps(reply, ensure_ascii=False, default=str, allow_nan=False)
+        except ValueError as exc:
+            _log("reply was not strict JSON (%r) for id=%r" % (exc, reply.get("id")))
+            reply = {"jsonrpc": "2.0", "id": reply.get("id"),
+                     "error": {"code": -32603,
+                               "message": "internal error: 返回值含非 JSON 数值（%s）" % exc}}
+            line = json.dumps(reply, ensure_ascii=False, default=str)
+        stdout.write((line + "\n").encode("utf-8"))
         stdout.flush()
 
 

package/smoke_test.py

@@ -27,6 +27,21 @@ PY = sys.executable
 STARTED_AT = time.strftime("%Y-%m-%dT%H:%M:%S")
 
 
+class NonStrictJSON(ValueError):
+    """The server wrote bare Infinity/NaN/-Infinity.
+
+    Python's json accepts those, RFC 8259 does not: dsh's client would fail on the
+    whole response and the tool would look dead rather than slightly wrong. A test
+    harness that tolerates it hides a real protocol defect, so we reject it here.
+    """
+
+
+def strict_loads(text):
+    def _reject(const):
+        raise NonStrictJSON("非标准 JSON 常量: %s" % const)
+    return json.loads(text, parse_constant=_reject)
+
+
 class Rpc:
     def __init__(self, python, script):
         self.p = subprocess.Popen([python, "-u", script], cwd=HERE,
@@ -64,7 +79,11 @@ class Rpc:
             with self.lock:
                 for raw in self.lines:
                     try:
-                        msg = json.loads(raw)
+                        msg = strict_loads(raw)
+                    except NonStrictJSON:
+                        # A reply carrying bare Infinity/NaN parses in Python but not
+                        # in a strict client, so dsh would report the tool as dead.
+                        raise SystemExit("服务器写出了非法 JSON：%s" % raw[:160])
                     except ValueError:
                         continue
                     if msg.get("id") == mine:
@@ -82,7 +101,10 @@ class Rpc:
         blocks = res.get("content", [])
         text = "".join(c.get("text", "") for c in blocks if c.get("type") == "text")
         try:
-            payload = json.loads(text)
+            payload = strict_loads(text)
+        except NonStrictJSON as exc:
+            payload = {"ok": False, "code": "bad_payload",
+                       "message": "工具返回体不是合法 JSON（%s）：%s" % (exc, text[:300])}
         except ValueError:
             payload = {"ok": False, "code": "bad_payload", "message": text[:400]}
         payload["_isError"] = res.get("isError", False)