trip-moments-skill 1.3.0 → 1.3.1

package/.agents/skills/trip-moments/scripts/imquality.py

@@ -8,11 +8,13 @@ from __future__ import annotations
 import base64
 import io
 import os
+import re
 import sys
+from functools import lru_cache
 from pathlib import Path
 
 import numpy as np
-from PIL import Image, ImageFilter, ImageOps, ImageFont
+from PIL import Image, ImageDraw, ImageFilter, ImageOps, ImageFont
 
 if sys.platform == "win32":
     try:
@@ -149,41 +151,152 @@ def palette(img: Image.Image, n: int = 5) -> list[tuple[int, int, int]]:
 
 
 # --- fonts (Cross-platform font paths; graceful fallback) ---------------------
-FONT_ZH_BOLD = ["msyhbd.ttc", "simhei.ttf", "msyh.ttc", "simsun.ttc", "NotoSansSC-Bold.otf", "PingFang.ttc"]
-FONT_ZH = ["msyh.ttc", "simsun.ttc", "simhei.ttf", "NotoSansSC-Regular.otf", "PingFang.ttc", "STHeiti.ttc"]
+# The names differ per platform because the *products* differ: Windows/macOS ship
+# their own CJK faces, while Debian/Ubuntu install the Noto **CJK** superfamily
+# (opentype/noto/NotoSansCJK-*.ttc) and Fedora/Arch often the SC subset instead.
+# Listing only the Windows names (plus NotoSansSC) meant a Linux server rendered
+# every Chinese glyph as the same .notdef box — measured in a python:3.11-slim
+# container: 「朋友圈旅行」 and 「敦煌戈壁滩」 produced byte-identical bitmaps both
+# before AND after `apt install fonts-noto-cjk`, because /usr/share/fonts was only
+# searched one level deep and the .ttc name was not a candidate at all.
+FONT_ZH_BOLD = [
+    "msyhbd.ttc", "simhei.ttf", "msyh.ttc", "simsun.ttc", "PingFang.ttc",
+    "NotoSansCJK-Bold.ttc", "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Bold.otf",
+    "NotoSansSC-Bold.otf", "SourceHanSansSC-Bold.otf", "wqy-zenhei.ttc",
+]
+FONT_ZH = [
+    "msyh.ttc", "simsun.ttc", "simhei.ttf", "PingFang.ttc", "STHeiti.ttc",
+    "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Regular.otf",
+    "NotoSansSC-Regular.otf", "SourceHanSansSC-Regular.otf", "NotoSerifCJK-Regular.ttc",
+    "wqy-zenhei.ttc",
+]
 FONT_EN = ["georgia.ttf", "times.ttf", "arial.ttf", "DejaVuSerif.ttf", "Helvetica.ttc"]
 
+# Any font on the box whose name looks CJK-capable is a valid last resort, which
+# is what makes this work on a distro whose naming we never anticipated.
+_CJK_NAME = re.compile(
+    r"(noto.{0,12}cjk|notosanssc|notoserifsc|sourcehan|wqy|droid.{0,8}fallback"
+    r"|msyh|simhei|simsun|pingfang|heiti|hiragino|uming|ukai)", re.IGNORECASE)
+_FONT_SUFFIXES = {".ttf", ".ttc", ".otf", ".otc"}
 
-def find_font(candidates: list[str], size: int) -> ImageFont.FreeTypeFont:
-    """Locate a usable font file across Windows, Linux, and macOS directories."""
-    search_dirs = [
-        Path(os.environ.get("WINDIR", "C:/Windows")) / "Fonts",
-        Path(os.environ.get("LOCALAPPDATA", "")) / "Microsoft" / "Windows" / "Fonts",
-        Path("/usr/share/fonts"),
-        Path("/usr/local/share/fonts"),
-        Path.home() / ".fonts",
-        Path.home() / ".local/share/fonts",
-        Path("/System/Library/Fonts"),
-        Path("/Library/Fonts"),
-    ]
-    for name in candidates:
-        for sdir in search_dirs:
-            if not sdir.exists():
+
+def _font_search_dirs() -> list[Path]:
+    """Font directories to scan, most specific first.
+
+    `TRIP_FONT_DIRS` (os.pathsep-separated) REPLACES the list when set: that is
+    the seam the selftest uses to isolate a Debian-like layout from whatever
+    fonts this machine happens to own. (A prepend would not isolate anything —
+    the machine's own CJK font would still win and hide the bug being tested.)
+    """
+    override = os.environ.get("TRIP_FONT_DIRS")
+    if override:
+        return [Path(p.strip()) for p in override.split(os.pathsep) if p.strip()]
+    dirs: list[Path] = []
+    win = os.environ.get("WINDIR") or "C:/Windows"
+    local = os.environ.get("LOCALAPPDATA")
+    dirs.append(Path(win) / "Fonts")
+    if local:
+        dirs.append(Path(local) / "Microsoft" / "Windows" / "Fonts")
+    dirs += [Path("/usr/share/fonts"), Path("/usr/local/share/fonts"),
+             Path.home() / ".fonts", Path.home() / ".local/share/fonts",
+             Path("/System/Library/Fonts"), Path("/Library/Fonts")]
+    return dirs
+
+
+@lru_cache(maxsize=8)
+def _font_index(dirs: tuple[str, ...]) -> dict[str, str]:
+    """name -> path for every font file under those dirs, searched RECURSIVELY.
+
+    Recursion is the whole point: Debian keeps Noto at
+    /usr/share/fonts/opentype/noto/..., so a one-level lookup finds nothing.
+    """
+    index: dict[str, str] = {}
+    for entry in dirs:
+        root = Path(entry)
+        try:
+            if not root.is_dir():
                 continue
-            p = sdir / name
-            if p.exists():
-                try:
-                    return ImageFont.truetype(str(p), size)
-                except OSError:
-                    continue
+            for path in root.rglob("*"):
+                if path.suffix.lower() in _FONT_SUFFIXES and path.is_file():
+                    index.setdefault(path.name, str(path))
+        except OSError:
+            continue
+    return index
+
+
+def _renders_cjk(font) -> bool:
+    """Does this font actually have CJK glyphs, or would it just draw tofu?
+
+    A font without CJK coverage maps every ideograph to the same .notdef box, so
+    two unrelated characters come out byte-identical. That is the check — the
+    same one that caught the Linux bug, kept here so it cannot come back.
+    """
+    def ink(text: str) -> bytes:
+        img = Image.new("L", (72, 72), 255)
+        ImageDraw.Draw(img).text((3, 3), text, font=font, fill=0)
+        return img.tobytes()
+
+    try:
+        return ink("朋") != ink("北")
+    except Exception:
+        return False
+
+
+def find_font(candidates: list[str], size: int) -> ImageFont.FreeTypeFont:
+    """Locate a usable font file across Windows, Linux, and macOS directories.
+
+    Prefers a font that can actually draw Chinese; falls back to a Latin face and
+    then to Pillow's own default (which has no CJK at all). The scanned dirs come
+    first and bare names are the last resort — bare names still cover setups our
+    scan cannot see (Windows' own font dir is on Pillow's search path, and
+    fontconfig-only Linux installs may hide faces behind aliases).
+
+    When `TRIP_FONT_DIRS` is set the search set is EXACTLY those directories and
+    no bare-name lookup happens, which is what lets the selftest reproduce a
+    Debian-like box instead of this machine's fonts.
+    """
+    override = bool(os.environ.get("TRIP_FONT_DIRS"))
+    dirs = tuple(str(d) for d in _font_search_dirs())
+    index = _font_index(dirs)
+    latin_fallback = None
+    # Any CJK-looking font present in the search set is a better answer than a
+    # Latin fallback, however the distro happens to name it.
+    names = list(candidates) + [n for n in index if _CJK_NAME.search(n)]
+
+    def consider(font):
+        nonlocal latin_fallback
+        if _renders_cjk(font):
+            return font
+        if latin_fallback is None:
+            latin_fallback = font
+        return None
+
+    for name in names:                                   # 1) the scanned dirs
+        path = index.get(name)
+        if not path:
+            continue
         try:
-            return ImageFont.truetype(name, size)
+            picked = consider(ImageFont.truetype(path, size))
         except OSError:
-            pass
+            continue
+        if picked is not None:
+            return picked
+
+    if not override:                                     # 2) Pillow's own search
+        for name in names:
+            try:
+                picked = consider(ImageFont.truetype(name, size))
+            except OSError:
+                continue
+            if picked is not None:
+                return picked
 
+    if latin_fallback is not None:                       # 3) no CJK anywhere
+        return latin_fallback
     for fallback in ["arial.ttf", "DejaVuSans.ttf"]:
+        path = index.get(fallback)
         try:
-            return ImageFont.truetype(fallback, size)
+            return ImageFont.truetype(path or fallback, size)
         except OSError:
             pass
     return ImageFont.load_default()

package/.agents/skills/trip-moments/scripts/selftest.py

@@ -3281,10 +3281,117 @@ def t_tray_gateway_discovery():
             srv.server_close()
 
 
+def t_font_selection_has_cjk():
+    """字体选择必须真的能画中文 —— 在服务器（Debian 布局）上曾经画成方块。
+
+    2026-10-04 在 python:3.11-slim 容器里实测：装不装 fonts-noto-cjk，「朋友圈旅行」
+    与「敦煌戈壁滩」都渲染成完全相同的位图（都是 .notdef 方块），因为
+    (a) /usr/share/fonts 只查了一层，而 Debian 把 Noto 放在 opentype/noto/ 下，
+    (b) 候选名单里写的是 NotoSansSC-*，Debian 只提供 NotoSansCJK-*。
+
+    本用例不依赖具体操作系统：用 TRIP_FONT_DIRS 造一个 Debian 式目录，看选择器能不能
+    递归找到它、并宁可选一个没列进名单但带中文的字体，也不返回列表更靠前却画不出中文的。
+    """
+    import shutil as _sh
+    import tempfile as _tf
+    from pathlib import Path as _P
+
+    import imquality as iq
+
+    dirs = tuple(str(d) for d in iq._font_search_dirs())
+    index = iq._font_index(dirs)
+    cjk_src = next((p for n, p in index.items() if iq._CJK_NAME.search(n)
+                    and iq._renders_cjk(iq.ImageFont.truetype(p, 32))), "")
+    latin_src = ""
+    for name in ("arial.ttf", "DejaVuSans.ttf", "georgia.ttf", "times.ttf", "Helvetica.ttc"):
+        path = index.get(name)
+        if not path:
+            continue
+        try:
+            font = iq.ImageFont.truetype(path, 32)
+        except OSError:
+            continue
+        if not iq._renders_cjk(font):
+            latin_src = path
+            break
+
+    # 反方向：缺字检测必须能认出“画不出中文”的字形 —— 用 Pillow 自带嵌入字体，
+    # 它没有 CJK 字形，且任何机器上都在（不让用例依赖本机凑巧装了某种拉丁字体）。
+    assert not iq._renders_cjk(iq.ImageFont.load_default()), \
+        "无 CJK 字形的字体被判为能画中文 —— 缺字检测失效，服务器上会静默画出方块"
+    if cjk_src:
+        assert iq._renders_cjk(iq.ImageFont.truetype(cjk_src, 32)), \
+            f"已知中文字体 {cjk_src} 被判为画不出中文"
+
+    if not cjk_src:
+        # 本机压根没装中文字体：反向判据已验，不再拿找不到的字体硬凑。
+        print("        (本机无中文字体，只验证了缺字检测不误报)")
+        return
+
+    old_env = os.environ.get("TRIP_FONT_DIRS")
+    with _tf.TemporaryDirectory() as tmp:
+        root = _P(tmp)
+        os.environ["TRIP_FONT_DIRS"] = str(root)
+        iq._font_index.cache_clear()
+        try:
+            # Debian 式布局：嵌套两层 + 名单外的名字，必须被递归找到并选中
+            (root / "opentype" / "noto").mkdir(parents=True)
+            wanted = root / "opentype" / "noto" / "NotoSansCJKjp-Light.ttc"
+            _sh.copyfile(cjk_src, wanted)
+            iq._font_index.cache_clear()
+            picked = iq.find_font(iq.FONT_ZH_BOLD, 32)
+            assert iq._renders_cjk(picked), \
+                f"递归目录里明明有中文字体，却选回了画不出中文的：{getattr(picked, 'path', picked)}"
+            assert str(getattr(picked, "path", "")).endswith("NotoSansCJKjp-Light.ttc"), \
+                ("应该选嵌套两层、名单外的那个中文字体（这才是「不靠硬编码名字」），"
+                 f"实际选了 {getattr(picked, 'path', picked)}")
+
+            # 像素级：两个不同汉字必须画出不同位图
+            def ink(text):
+                img = iq.Image.new("L", (80, 80), 255)
+                iq.ImageDraw.Draw(img).text((3, 3), text, font=picked, fill=0)
+                return img.tobytes()
+            assert ink("朋") != ink("北"), "两个不同汉字画出同一张图 —— 就是缺字方块"
+
+            # 搜索集里只有画不出中文的字体时，宁可降级也不能假装能画。
+            # 必须用一个全新的目录：刚才那个临时目录里已经放了中文字体。
+            if latin_src:
+                os.environ["TRIP_FONT_DIRS"] = str(root / "only-latin")
+                (root / "only-latin").mkdir()
+                _sh.copyfile(latin_src, root / "only-latin" / "latin-only.ttf")
+                iq._font_index.cache_clear()
+                only = iq.find_font(iq.FONT_ZH_BOLD, 32)
+                assert not iq._renders_cjk(only), \
+                    "搜索集里只有拉丁字体，却被报告为能画中文（选字逻辑在蒙）"
+            else:
+                print("        (本机无拉丁字体文件，略过“只有拉丁字体”的降级子用例)")
+        finally:
+            iq._font_index.cache_clear()
+            if old_env is None:
+                os.environ.pop("TRIP_FONT_DIRS", None)
+            else:
+                os.environ["TRIP_FONT_DIRS"] = old_env
+
+
+def t_linux_font_layout_declared():
+    """font 目录必须递归搜索：Debian 把 Noto 放在 opentype/noto/ 下。
+
+    这条不依赖机器上有没有中文字体，只查源码契约：搜素用 rglob 而不是直接拼一层；
+    候选名单里必须包含各发行版真实使用的 Noto CJK 文件名。
+    """
+    src = (Path(__file__).parent / "imquality.py").read_text(encoding="utf-8")
+    assert "rglob" in src, "字体目录退回单层扫描 —— Debian 的 opentype/noto/ 会找不到"
+    for name in ("NotoSansCJK-Bold.ttc", "NotoSansCJK-Regular.ttc", "NotoSansCJKsc-Regular.otf"):
+        assert name in src, f"候选名单缺少发行版实际使用的字体名：{name}"
+    assert "_renders_cjk" in src and "load_default" in src, "缺少「画不出中文就继续找」的判据"
+
+
 CASES = {
     "打包交付与下载(zip/预览/越权拦截)": t_finish_deliverables_and_download,
     "AI 结果可见性+三套候选(每步输出框/agent轨道)": t_claw_grade_candidates_and_output_visibility,
     "Agent自带模型轨道也给三档候选(预览/采用)": t_agent_model_grade_candidates,
+    "字体选择真的能画中文(递归+缺字检测)": t_font_selection_has_cjk,
+    "字体目录递归与发行版字体名": t_linux_font_layout_declared,
     "OpenClaw WSL gateway 发现(端点未启用的诚实报告)": t_tray_gateway_discovery,
     "存活探测不误杀冷实例/代理环境": t_liveness_probe_is_cheap_and_proxy_safe,
     "审片页 STUDIO 链接跟随在跑实例": t_review_studio_link_follows_instance,

package/bin/install.js

@@ -16,7 +16,7 @@ const path = require('path');
 const os = require('os');
 const { execSync, spawnSync } = require('child_process');
 
-const VERSION = '1.3.0';
+const VERSION = '1.3.1';
 const SKILL_NAME = 'trip-moments';
 
 const c = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trip-moments-skill",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "AI 朋友圈旅行出图助手 (trip-moments skill) — 工业级全流程旅行摄影智能出图与朋友圈九宫格套件",
   "main": "bin/install.js",
   "bin": {