dsh-muv-table 0.2.4 → 0.2.7

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## v0.2.7 (2026-09-20)
+
+### 📦 发布内容修正
+
+- **把 `test-png-card.mjs` 纳入 npm 包**。0.2.6 的 README 让用户跑
+  `node test-png-card.mjs`，但 `files` 字段没列它，从 npm 安装的人拿不到。
+  现在一并发布，装完即可自测 PNG 卡解析是否正常（含真实卡库验证，卡库不存在时自动跳过）。
+- `README.md` 显式列入 `files`。
+
+> 0.2.6 的功能改动见下。
+
+## v0.2.6 (2026-09-20)
+
+### 🐛 修复：变量面板显示错误的卡（显示成苍玄界）
+
+两个独立原因，都会让面板拿到**别的预设**的卡：
+
+- **无 `presetId` 时回退到硬编码预设**：面板只在收到 `tavern-preset-changed`
+  事件后才设置 `lastPresetId`，而页面首次加载时该事件不会触发，请求因此不带
+  参数；服务端于是回退到写死的 `tavern-lite`，把那个预设的卡显示出来。
+  现在新增 `/api/muv-table/active-preset`，面板在首次加载前先问服务端
+  「当前是哪个预设」，服务端按**最近写入的会话**所绑定的预设来回答。
+- **过期 managed copy**：`tavern-lite/muv-tables/card.json` 里是 8 月留下的
+  苍玄界，而该预设的 `characters.json` 早已改成川上富江。现在 `card.json`
+  的卡名与预设记录不一致时不再采用，转而走卡库匹配，避免张冠李戴。
+
+### ✨ 支持读取 SillyTavern 的 PNG 角色卡
+
+- **新增 `lib/png-card.js`**：从 PNG 的 `tEXt`/`iTXt` 元数据里解出 `chara` 块
+  （base64 编码的卡 JSON）。这是 TavernAI 系生态的标准做法——图片本身就是卡，
+  角色数据搭车存在文件里，所以一张 3.5 MB 的「卡」实际是封面图 + 约 1.5 MB 的
+  base64 卡数据。
+- **为什么需要**：DSH 自己的导入器只把 `{name, desc, first, enabled}` 写进
+  `characters.json`，**正则脚本、世界书、tavern_helper 全部丢失**。所以一张拖进
+  SillyTavern 的卡，在 DSH 这边只能拿到 3 KB 文本残影。现在直接读原始 PNG 文件。
+- **卡库搜索路径接入 SillyTavern**：自动发现
+  `<SillyTavern>/data/<user>/characters`（含 `C:/MySpecialFolder/SillyTavern`、
+  `~/SillyTavern`、`~/Documents/SillyTavern`），可用 `DSH_SILLYTAVERN_DIR`
+  覆盖。预设目录里直接放 `.png` 也会被识别。
+- `findJsonMatch` 同时接受 `.json` 与 `.png`，按卡名匹配。
+
+实测：SillyTavern 卡库 5 张 PNG 卡全部读出，其中 4 张带回完整正则脚本
+（足控天堂 10 个、异世界农场 3 个、涩涩提瓦特 2 个、食人世界 2 个）。
+
+### 🧪 测试
+
+- 新增 `test-png-card.mjs`：12 项，覆盖合成 PNG 解析、无 `chara` 块拒绝、
+  垃圾数据不抛异常，以及真实卡库验证（卡库不存在时自动跳过）。
+
+## v0.2.5 (2026-09-20)
+
+### 🐛 修复：变量面板读不到已导入的卡
+
+- **新增 `extractMuvFromCharactersJson`**：酒馆把导入的卡存在
+  `<预设目录>/characters.json`。此前面板只认两条路——预设里的
+  `muv-tables/card.json`，或按卡名在外部卡库目录里找原始 JSON 文件。
+  导入的卡往往两条都不满足（原始文件根本没下载到本机），于是接口返回
+  `found:false`、变量面板空白，**而数据其实就在 characters.json 里**。
+  现在第三条路直接从那里提取变量表。
+- 同时支持两种编码：`<VariableInsert>{…纯 JSON…}`（社区卡常见）与
+  MUV 原生的 `<UpdateVariable><initvar>…</initvar></UpdateVariable>`。
+- 过滤掉 `主播档案.$template` 占位条目，它不是真实角色。
+
+### 🐛 修复：角色卡读取路径过窄
+
+- `MUV_CARD_DIRS` 之前硬编码了某一台机器的下载目录，换台机器就找不到卡。
+  现在按顺序尝试：预设目录 `muv-tables/card.json`、`DSH_MUV_CARD_DIRS`
+  环境变量、系统下载目录、桌面。
+- 角色卡名可从酒馆的 `characters.json` 读取，不再依赖单一 yml 字段。
+- `tavern-card` 接口支持按 `presetId` / `sessionId` 取卡，并返回
+  `regexScripts` 与 `data.extensions.regex_scripts` 两种正则脚本形态。
+
 ## v0.2.4 (2026-09-13)
 
 ### 📝 文档

package/README.md

@@ -4,6 +4,47 @@ MUV 变量表格编辑器 —— 酒馆伴生插件。
 
 > 🍺 本插件是 [dsh-tavern-v2](https://github.com/chen731215-dev/dsh-tavern-v2) 的扩展，需配合酒馆使用。
 
+## 🆕 v0.2.6 更新内容
+
+### 新增：读取 SillyTavern 的 PNG 角色卡
+
+这是本次最重要的能力。SillyTavern（及整个 TavernAI 系生态）的角色卡就是**一张 PNG**——
+卡数据以 base64 存在图片的 `tEXt` 元数据里。一张 3.5 MB 的「卡」实际是封面图 +
+约 1.5 MB 的卡数据。
+
+**为什么必须读它**：DSH 自己的导入器只把 `{name, desc, first}` 写进 `characters.json`，
+**正则脚本、世界书、tavern_helper 全部丢失**。于是一张拖进酒馆的卡，在 DSH 这边只剩
+3 KB 文本残影，卡自带的插画、视频、状态栏渲染全都不工作。现在直接读原始 PNG 文件。
+
+- 新增 `lib/png-card.js`：解析 PNG 的 `tEXt`/`iTXt` 元数据，取出 `chara` 块
+- 卡库搜索路径自动接入 `<SillyTavern>/data/<user>/characters`
+  （含 `~/SillyTavern`、`~/Documents/SillyTavern`、`C:/MySpecialFolder/SillyTavern`），
+  可用环境变量 `DSH_SILLYTAVERN_DIR` 覆盖
+- 预设目录里直接放 `.png` 也会被识别
+
+实测：SillyTavern 卡库 5 张 PNG 卡全部读出，带回了完整的正则脚本与上百条世界书。
+
+### 修复：变量面板显示错误的卡
+
+两个独立原因都会让面板拿到**别的预设**的卡：
+
+- 面板在首次加载时不知道自己在哪个预设（预设切换事件不会在页面加载时触发），
+  请求不带参数，服务端回退到**硬编码的** `tavern-lite`，把那个预设的卡显示出来。
+  现在新增 `/api/muv-table/active-preset`，面板主动询问当前预设。
+- 面板会把首次解析出的预设**缓存住永不更新**，切换预设后卡死在旧卡上。现在每次
+  轮询都重读。
+- 预设里的 `muv-tables/card.json` 可能是过期残留（卡名与 `characters.json` 不符），
+  现在会被识别并忽略。
+
+### 新增：从 `characters.json` 提取变量表
+
+酒馆把导入的卡存在 `<预设目录>/characters.json`。当原始卡文件不在本机时，
+**这是变量数据唯一还存在的地方**。现在会从这里提取，支持
+`<VariableInsert>{…JSON…}` 与 MUV 原生的 `<UpdateVariable><initvar>…</initvar>` 两种编码。
+
+> 回归测试：`node test-png-card.mjs`（12 项，含真实卡库验证）
+
+
 ## 是什么
 
 把酒馆角色卡的 MUV 变量渲染成结构化表格，Agent 直接编辑表格即可生成格式100%正确的 `<UpdateVariable>` 块，彻底避免 DeepSeek 漏变量、缩进错、标签不闭合的问题。

package/lib/client.js

@@ -155,7 +155,48 @@ window.__ModuleLoader__.load({
       const hasAutoLoaded = React.useRef(false)
 
       // Get the tavern's active card
+      //
+      // Which preset is active has exactly one source of truth: the tavern
+      // plugin's own selection, which it publishes on these DOM nodes (and
+      // mirrors to localStorage). `lastPresetId` was previously only set by a
+      // `tavern-preset-changed` event, which does not fire on page load — so the
+      // first request carried no preset and the server fell back to a hardcoded
+      // one, showing an unrelated card.
+      //
+      // Reading the DOM here rather than caching an event value matters: the
+      // panel polls, and the user can switch presets at any time. An earlier
+      // revision cached the first answer and never re-checked, which pinned the
+      // panel to whatever preset happened to be active when it opened.
+      const readActivePresetFromDom = () => {
+        try {
+          for (const id of ['tavern-session-preset-label', 'tavern-session-preset-btn']) {
+            const el = document.getElementById(id)
+            const pid = el && el.dataset && el.dataset.presetId
+            if (pid) return pid
+          }
+          const item = document.querySelector('#tavern-session-preset-panel [data-preset-id]')
+          const aid = item && item.getAttribute && item.getAttribute('data-preset-id')
+          if (aid) return aid
+        } catch (_) {}
+        try { return localStorage.getItem('dsh-tavern-active-preset') || '' } catch (_) { return '' }
+      }
+
+      const resolveActivePreset = async () => {
+        // Tavern's DOM is authoritative and updates the moment the user switches.
+        const fromDom = readActivePresetFromDom()
+        if (fromDom) { lastPresetId = fromDom; return lastPresetId }
+        // The DOM nodes are absent outside the tavern UI; ask the server, which
+        // resolves the preset from the most recently active session.
+        try {
+          const r = await fetch('/api/muv-table/active-preset')
+          const d = await r.json()
+          if (d && d.ok && d.presetId) lastPresetId = d.presetId
+        } catch (_) {}
+        return lastPresetId
+      }
+
       const fetchTavernCard = async () => {
+        await resolveActivePreset()
         let url = '/api/muv-table/tavern-card'
         if (lastPresetId) url += '?presetId=' + encodeURIComponent(lastPresetId)
         const r = await fetch(url)

package/lib/index.js

@@ -4,6 +4,7 @@
 import { parseMuvCard } from './muv-parser.js'
 import { generateMuvBlock, applyEditsAndGenerate } from './block-generator.js'
 import { parseInitvar } from './initvar-parser.js'
+import { readPngCard } from './png-card.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
@@ -52,7 +53,46 @@ function bindDshPaths(ctx) {
   SESSION_BINDINGS_FILE = path.join(PRESETS_ROOT, 'session-bindings.json')
 }
 
-const MUV_CARD_DIRS = ['E:/BaiduNetdiskDownload/EdgeDownload']
+// External character-card library searched when a preset has no managed copy.
+// Historically this was a single hardcoded download folder, which silently
+// limited every lookup to whatever happened to sit there. Keep that folder
+// first (existing installs rely on it), then widen to the other places cards
+// actually get downloaded to, and allow an explicit override.
+//
+// The SillyTavern folders matter because that is where a user's *original* PNG
+// cards live. DSH's own `characters.json` keeps only `{name, desc, first}`, so
+// for a card dragged into SillyTavern the original file is the only place its
+// regex scripts, world book and helper scripts still exist.
+function sillyTavernCharacterDirs() {
+  const roots = []
+  const explicit = process.env.DSH_SILLYTAVERN_DIR
+  if (explicit) roots.push(explicit)
+  // Common install locations; each may hold data/<user>/characters.
+  roots.push('C:/MySpecialFolder/SillyTavern')
+  roots.push(path.join(os.homedir(), 'SillyTavern'))
+  roots.push(path.join(os.homedir(), 'Documents', 'SillyTavern'))
+
+  const out = []
+  for (const root of roots) {
+    try {
+      const dataDir = path.join(root, 'data')
+      if (!fs.existsSync(dataDir)) continue
+      for (const user of fs.readdirSync(dataDir)) {
+        const chars = path.join(dataDir, user, 'characters')
+        if (fs.existsSync(chars)) out.push(chars)
+      }
+    } catch (_) {}
+  }
+  return out
+}
+
+const MUV_CARD_DIRS = [
+  'E:/BaiduNetdiskDownload/EdgeDownload',
+  ...(process.env.DSH_MUV_CARD_DIRS || '').split(path.delimiter).map(s => s.trim()).filter(Boolean),
+  ...sillyTavernCharacterDirs(),
+  path.join(os.homedir(), 'Downloads'),
+  path.join(os.homedir(), 'Desktop')
+].filter((dir, i, all) => all.indexOf(dir) === i)
 
 /** Read a YAML/yml file with encoding detection (GBK → UTF-8 fallback). */
 function readYmlSafe(filePath) {
@@ -73,15 +113,22 @@ function readYmlSafe(filePath) {
  */
 function extractCardNameFromYml(yml) {
   if (!yml) return ''
-  // 1) Find the persona text: |- block first (the actual character card content)
-  const textMatch = yml.match(/text:\s*\|-?\s*\n([\s\S]*?)(?=\n\s*[-a-zA-Z@_]+:|\n\s*$)/)
-  const body = textMatch ? textMatch[1] : yml
+  // 1) Find the persona body. Tavern writes `prefix: |-`; other generators use
+  //    `text:`. Matching only `text:` made everything below scan raw YAML,
+  //    where the first non-comment line is the persona *service* name.
+  const textMatch = yml.match(/(?:prefix|text):\s*\|-?\s*\n([\s\S]*?)(?=\n\s*[-a-zA-Z@_]+:|\n\s*$)/)
+  const body = textMatch ? textMatch[1] : ''
   // 2) 角色名：xxx pattern (used by tavern cards)
   const personaMatch = body.match(/角色名[：:]\s*([^\s#\n]+)/)
   if (personaMatch) return personaMatch[1].trim()
-  // 3) First meaningful line of the persona block (card title)
-  const firstLine = body.split(/\r?\n/).map(l => l.trim()).find(l => l && !l.startsWith('#') && !l.startsWith('-') && !l.startsWith('['))
-  if (firstLine) return firstLine.replace(/[#*_【】「」]/g, '').trim()
+  // 3) Card title: the first meaningful line of the persona body only — never
+  //    fall back to the raw YAML, whose lines are configuration keys.
+  const firstLine = body.split(/\r?\n/).map(l => l.trim())
+    .find(l => l && !l.startsWith('#') && !l.startsWith('-') && !l.startsWith('[') && !/^[a-zA-Z@_][\w@./-]*:/.test(l))
+  if (firstLine) {
+    const cleaned = firstLine.replace(/[#*_【】「」]/g, '').replace(/[🔒🔓]\s*/g, '').trim()
+    if (cleaned) return cleaned
+  }
   // 4) Upstream structured name: — but skip service names like '@deepseek-ai/dsh-persona'
   const nameMatch = yml.match(/^\s*name:\s*(.+)$/m)
   if (nameMatch) {
@@ -130,15 +177,71 @@ function presetDirForSession(sessionId) {
 }
 
 /**
- * Search a person text for a matching card JSON in MUV dirs.
- * Returns parsed card or null.
+ * Which preset is the user actually in?
+ *
+ * The panel opens without knowing the session, and `tavern-lite` was the
+ * hardcoded fallback — so a user working in another preset saw *that* preset's
+ * card in the variable panel (a stale 苍玄界 copy, in the reported case).
+ *
+ * The most reliable signal available server-side is the session store: the
+ * binding belonging to the most recently written session is the one on screen.
+ * @returns {string} a preset directory name, or '' when nothing can be resolved
+ */
+function activePresetId() {
+  try {
+    if (!fs.existsSync(SESSION_BINDINGS_FILE)) return ''
+    const bind = JSON.parse(fs.readFileSync(SESSION_BINDINGS_FILE, 'utf8'))
+
+    // Session transcripts live under <dshHome>/storages/session_projcache/sessions
+    const sessDir = path.join(DSH_HOME, 'storages', 'session_projcache', 'sessions')
+    if (fs.existsSync(sessDir)) {
+      const files = fs.readdirSync(sessDir)
+        .filter(f => f.startsWith('session-') && f.endsWith('.json'))
+        .map(f => {
+          let mtime = 0
+          try { mtime = fs.statSync(path.join(sessDir, f)).mtimeMs } catch (_) {}
+          return { id: f.replace(/\.json$/, ''), mtime }
+        })
+        .sort((a, b) => b.mtime - a.mtime)
+
+      for (const s of files) {
+        const preset = bind[s.id]
+        if (preset && preset !== 'default') {
+          if (fs.existsSync(path.join(PRESETS_ROOT, preset))) return preset
+        }
+      }
+    }
+  } catch (_) {}
+  return ''
+}
+
+/**
+ * Search the MUV card dirs for a card matching a name.
+ *
+ * Reads both `.json` cards and SillyTavern `.png` cards — the latter carries
+ * the full card (regex scripts, world book, helper scripts) in a `tEXt` chunk,
+ * which is the only place that data survives when a card was dragged into
+ * SillyTavern rather than imported through DSH.
+ * @param {string} cardNameLower
+ * @param {string[]} dirs
+ * @returns {{json:object, fileName:string}|null}
  */
 function findJsonMatch(cardNameLower, dirs) {
   for (const dir of dirs) {
     if (!fs.existsSync(dir)) continue
-    for (const f of fs.readdirSync(dir).filter(f2 => f2.endsWith('.json'))) {
+    let files
+    try { files = fs.readdirSync(dir) } catch (_) { continue }
+    for (const f of files) {
+      const isJson = f.endsWith('.json')
+      const isPng = f.endsWith('.png')
+      if (!isJson && !isPng) continue
       try {
-        const json = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'))
+        let json
+        if (isPng) {
+          json = readPngCard(path.join(dir, f))
+        } else {
+          json = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8'))
+        }
         const name = json?.data?.name || json?.name || ''
         if (!name) continue
         if (cardNameLower && (name.toLowerCase().includes(cardNameLower) || cardNameLower.includes(name.toLowerCase()))) {
@@ -150,6 +253,164 @@ function findJsonMatch(cardNameLower, dirs) {
   return null // No fallback — if no exact match, use yml extraction
 }
 
+/**
+ * Read the active character name from a preset's tavern-managed store.
+ *
+ * `characters.json` is where tavern actually records the imported card
+ * (`[{ name, desc, first, enabled }]`), so it is the authoritative card name.
+ * Parsing the persona YAML only yields the preset module's title, which is a
+ * different thing entirely.
+ * @param {string} presetDir - absolute preset directory
+ * @returns {string} the enabled character's name, or ''
+ */
+function cardNameFromCharactersJson(presetDir) {
+  const file = path.join(presetDir, 'characters.json')
+  if (!fs.existsSync(file)) return ''
+  try {
+    const list = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (!Array.isArray(list)) return ''
+    const enabled = list.find(c => c && c.enabled && c.name)
+    if (enabled) return String(enabled.name).trim()
+    const first = list.find(c => c && c.name)
+    return first ? String(first.name).trim() : ''
+  } catch (_) {
+    return ''
+  }
+}
+
+/**
+ * Load the full raw character card for a preset, so its `regex_scripts` are
+ * available to the rendering engine.
+ *
+ * The tavern/MUV-managed copy inside the preset (`muv-tables/card.json`) is the
+ * authoritative one: it is the card the user actually imported and edited, and
+ * it is the only location guaranteed to sit next to the preset that uses it.
+ * Only when it is absent do we fall back to matching by name against the
+ * external card library.
+ * @param {string} presetDir - absolute preset directory
+ * @param {string} cardName - card name resolved from the preset's persona
+ * @returns {{ json: object, fileName: string, source: string }|null}
+ */
+function loadRawCardForPreset(presetDir, cardName) {
+  const managed = path.join(presetDir, 'muv-tables', 'card.json')
+  if (fs.existsSync(managed)) {
+    try {
+      const json = JSON.parse(fs.readFileSync(managed, 'utf8'))
+      const managedName = String(json?.data?.name || json?.name || '')
+      // The managed copy goes stale: `tavern-lite` held a 苍玄界 card from
+      // August while the preset's characters.json had moved on to 川上富江.
+      // Serving it anyway showed the wrong card in the variable panel, so only
+      // trust it when the names actually agree. (An empty name means the card
+      // carries none — then there is nothing to contradict, so keep it.)
+      const wanted = String(cardName || '')
+      const agrees = !managedName || !wanted
+        || managedName.toLowerCase().includes(wanted.toLowerCase())
+        || wanted.toLowerCase().includes(managedName.toLowerCase())
+      if (agrees) {
+        return { json, fileName: path.basename(presetDir) + '/muv-tables/card.json', source: 'preset' }
+      }
+    } catch (_) {}
+  }
+  // A PNG card sitting next to the preset — the user may have dropped the
+  // original file there instead of letting tavern import it.
+  try {
+    for (const f of fs.readdirSync(presetDir)) {
+      if (!f.endsWith('.png')) continue
+      const json = readPngCard(path.join(presetDir, f))
+      if (!json) continue
+      const name = json?.data?.name || json?.name || ''
+      if (!cardName || !name) continue
+      const a = name.toLowerCase(), b = String(cardName).toLowerCase()
+      if (a.includes(b) || b.includes(a)) {
+        return { json, fileName: path.basename(presetDir) + '/' + f, source: 'preset-png' }
+      }
+    }
+  } catch (_) {}
+  const match = findJsonMatch(String(cardName || '').toLowerCase(), MUV_CARD_DIRS)
+  if (match) return { ...match, source: 'library' }
+  return null
+}
+
+/**
+ * Pull the card's regex scripts in whatever shape the card carries them.
+ * @param {object|null} cardJson
+ * @returns {object[]}
+ */
+function regexScriptsOf(cardJson) {
+  const scripts = cardJson?.data?.extensions?.regex_scripts
+  return Array.isArray(scripts) ? scripts : []
+}
+
+/**
+ * Extract the card's variable schema from tavern's own character store.
+ *
+ * Tavern keeps what it imported in `<presetDir>/characters.json`, so for a card
+ * whose original JSON file is not in any searched library folder this is the
+ * only place the variables still exist. Two encodings appear in the field:
+ *
+ *  - `<VariableInsert>{…JSON…}</VariableInsert>` — community cards that ship a
+ *    plain JSON schema (this is what the 足控-style cards use).
+ *  - `<UpdateVariable><initvar>…</initvar></UpdateVariable>` — the MUV-native
+ *    YAML-ish form.
+ *
+ * Without this, a preset imported like that reported `found:false` and the
+ * variable panel stayed empty even though the data was sitting right there.
+ * @param {string} presetDir
+ * @returns {{name:string, schemas:object[], initvarData:object, initvarBlocks:string[], zodSource:string, cardName:string}|null}
+ */
+function extractMuvFromCharactersJson(presetDir) {
+  try {
+    const file = path.join(presetDir, 'characters.json')
+    if (!fs.existsSync(file)) return null
+    const list = JSON.parse(fs.readFileSync(file, 'utf8'))
+    if (!Array.isArray(list) || !list.length) return null
+    const card = list.find(c => c && c.enabled) || list[0]
+    if (!card) return null
+    const name = String(card.name || '').trim() || 'MUV Card'
+    const text = String(card.desc || '') + '\n' + String(card.first || '')
+
+    // 1) Plain-JSON schema.
+    const vi = text.match(/<VariableInsert>([\s\S]*?)<\/VariableInsert>/i)
+    if (vi) {
+      const body = vi[1].trim()
+      try {
+        const data = JSON.parse(body)
+        // `$template` is the card's own placeholder entry, not a real character.
+        const clean = { ...data }
+        if (clean['主播档案'] && clean['主播档案'].$template) {
+          clean['主播档案'] = { ...clean['主播档案'] }
+          delete clean['主播档案'].$template
+        }
+        return {
+          name, cardName: name,
+          schemas: inferSchemas(clean),
+          initvarData: clean,
+          initvarBlocks: [body],
+          zodSource: ''
+        }
+      } catch (_) {
+        // Fall through: the block may still be YAML-ish.
+      }
+    }
+
+    // 2) MUV-native initvar.
+    const iv = text.match(/<initvar>([\s\S]*?)<\/initvar>/i)
+    if (iv) {
+      const parsed = parseInitvar(iv[1])
+      return {
+        name, cardName: name,
+        schemas: inferSchemas(parsed),
+        initvarData: parsed,
+        initvarBlocks: [iv[1]],
+        zodSource: ''
+      }
+    }
+    return null
+  } catch (_) {
+    return null
+  }
+}
+
 /**
  * Extract MUV card info from a preset's persona YAML/yml text.
  * Looks for <initvar> blocks and builds a fake card object for parseMuvCard.
@@ -310,6 +571,18 @@ export function apply(ctx) {
         }
       }
     },
+    {
+      kind: 'exact',
+      path: '/api/muv-table/active-preset',
+      handler: (req, res) => {
+        try {
+          const presetId = activePresetId()
+          json(res, 200, { ok: true, presetId, fallback: presetId ? '' : path.basename(TAVERN_PRESET_DIR) })
+        } catch (e) {
+          json(res, 500, { ok: false, error: e.message })
+        }
+      }
+    },
     {
       kind: 'exact',
       path: '/api/muv-table/tavern-card',
@@ -317,48 +590,84 @@ export function apply(ctx) {
         try {
           const url = new URL(req.url, 'http://localhost')
           const presetId = url.searchParams.get('presetId') || ''
+          const sessionId = url.searchParams.get('sessionId') || ''
 
-          // If a specific preset is requested, read from that preset's directory
-          let ymlPath, presetDir
+          // Resolve the preset: explicit id > the session's bound preset >
+          // whichever preset the user is actually in. The last resort used to be
+          // a hardcoded `tavern-lite`, which made the panel show that preset's
+          // card (a stale 苍玄界 copy) whenever the client had no preset id yet
+          // — which is the common case, since the id only arrives via a
+          // `tavern-preset-changed` event that never fires on a fresh page.
+          let presetDir
           if (presetId) {
             presetDir = path.join(PRESETS_ROOT, presetId)
-            ymlPath = path.join(presetDir, 'agent.cordis.yml')
+          } else if (sessionId) {
+            presetDir = presetDirForSession(sessionId)
           } else {
-            presetDir = TAVERN_PRESET_DIR
-            ymlPath = path.join(TAVERN_PRESET_DIR, 'agent.cordis.yml')
+            const active = activePresetId()
+            presetDir = active ? path.join(PRESETS_ROOT, active) : TAVERN_PRESET_DIR
           }
+          if (!fs.existsSync(presetDir)) presetDir = TAVERN_PRESET_DIR
+          const ymlPath = path.join(presetDir, 'agent.cordis.yml')
 
           let yml = fs.existsSync(ymlPath) ? readYmlSafe(ymlPath) : ''
-          let cardName = extractCardNameFromYml(yml)
-
-          if (!cardName) {
-            const allPresets = scanAllPresetCards()
-            const nonEmpty = allPresets.filter(p => p.cardName).sort((a, b) => b.mtime - a.mtime)
-            if (nonEmpty.length > 0) {
-              cardName = nonEmpty[0].cardName
-              yml = nonEmpty[0].yml
-            }
-          }
+          // Prefer tavern's own character store; fall back to the persona YAML.
+          let cardName = cardNameFromCharactersJson(presetDir) || extractCardNameFromYml(yml)
 
-          const match = findJsonMatch(String(cardName || '').toLowerCase(), MUV_CARD_DIRS)
-
-          if (match) {
-            const result = parseMuvCard(match.json)
+          // The raw card is the source of regex_scripts. Prefer the preset's own
+          // card; fall back to the external library matched by name.
+          const raw = loadRawCardForPreset(presetDir, cardName)
+          if (raw) {
+            const regexScripts = regexScriptsOf(raw.json)
             json(res, 200, {
-              ok: true, found: true, fileName: match.fileName,
-              cardName, presetDir: path.basename(presetDir),
-              ...result
+              ok: true, found: true,
+              fileName: raw.fileName,
+              cardSource: raw.source,
+              cardName,
+              presetDir: path.basename(presetDir),
+              ...parseMuvCard(raw.json),
+              // Consumers read the scripts from either shape; keep both so an
+              // existing reader keeps working while the engine migrates.
+              regexScripts,
+              data: { extensions: { regex_scripts: regexScripts } }
             })
-          } else if (cardName && yml) {
+            return
+          }
+
+          if (cardName && yml) {
+            // Neither a managed copy nor a library file: read the schema out of
+            // tavern's own character store. Imported cards routinely live only
+            // here, and returning found:false left the variable panel empty
+            // while the data sat in characters.json.
+            const fromStore = extractMuvFromCharactersJson(presetDir)
+            if (fromStore) {
+              json(res, 200, {
+                ok: true, found: true,
+                fileName: path.basename(presetDir) + '/characters.json',
+                cardSource: 'characters',
+                cardName: fromStore.cardName || cardName,
+                presetDir: path.basename(presetDir),
+                name: fromStore.name,
+                schemas: fromStore.schemas,
+                initvarData: fromStore.initvarData,
+                initvarBlocks: fromStore.initvarBlocks,
+                zodSource: fromStore.zodSource,
+                regexScripts: [],
+                data: { extensions: { regex_scripts: [] } }
+              })
+              return
+            }
             const parsed = extractMuvFromYml(yml)
             json(res, 200, {
               ok: true, found: true,
               fileName: path.basename(presetDir) + '/agent.cordis.yml',
               cardName, presetDir: path.basename(presetDir),
-              ...parsed
+              ...parsed,
+              regexScripts: [],
+              data: { extensions: { regex_scripts: [] } }
             })
           } else {
-            json(res, 200, { ok: true, found: false, error: 'no card in preset' })
+            json(res, 200, { ok: true, found: false, error: 'no card in preset', regexScripts: [] })
           }
         } catch (e) {
           json(res, 500, { ok: false, error: e.message })

package/lib/png-card.js

@@ -0,0 +1,126 @@
+// PNG character-card reader.
+//
+// SillyTavern (and the whole TavernAI-derived ecosystem) stores a card inside
+// the PNG's metadata: a `tEXt` chunk whose keyword is `chara`, holding the card
+// JSON as base64. The image itself is just the avatar — the card data rides
+// along in the file, which is why a 3.5 MB "card" is really a picture plus
+// ~1.5 MB of base64 payload.
+//
+// DSH's own importer never looked at these files: it only ever read its
+// `characters.json` store, which keeps just `{name, desc, first, enabled}`. So a
+// card dragged in as PNG arrived stripped of its regex scripts, world book and
+// helper scripts. This module reads the original file instead.
+
+import fs from 'node:fs'
+
+/**
+ * Walk a PNG's chunks.
+ *
+ * PNG layout: 8-byte signature, then chunks of
+ * `length(4) type(4) data(length) crc(4)`, ending at IEND.
+ * @param {Buffer} buf
+ * @returns {{type:string, len:number, off:number}[]}
+ */
+export function readPngChunks(buf) {
+  const chunks = []
+  if (!buf || buf.length < 8) return chunks
+  let off = 8
+  // Guard against a malformed length field running us off the end.
+  while (off + 8 <= buf.length) {
+    const len = buf.readUInt32BE(off)
+    const type = buf.toString('ascii', off + 4, off + 8)
+    if (!/^[A-Za-z]{4}$/.test(type)) break
+    chunks.push({ type, len, off })
+    if (type === 'IEND') break
+    off += 12 + len
+    if (len < 0) break
+  }
+  return chunks
+}
+
+/**
+ * Pull the `chara` payload out of a PNG's text chunks.
+ *
+ * Both `tEXt` and `iTXt` appear in the wild. `tEXt` is `keyword\0text`, while
+ * `iTXt` is `keyword\0 compressionFlag(1) compressionMethod(1) langTag\0
+ * translatedKeyword\0 text` — the extra header bytes have to be skipped or the
+ * base64 decodes to garbage.
+ * @param {Buffer} buf
+ * @returns {string|null} the raw (still base64) payload
+ */
+export function extractCharaPayload(buf) {
+  for (const c of readPngChunks(buf)) {
+    if (c.type !== 'tEXt' && c.type !== 'iTXt') continue
+    const body = buf.subarray(c.off + 8, c.off + 8 + c.len)
+    const nul = body.indexOf(0)
+    if (nul < 0) continue
+    const keyword = body.toString('latin1', 0, nul)
+    if (keyword !== 'chara' && keyword !== 'ccv3') continue
+
+    let rest = body.subarray(nul + 1)
+    if (c.type === 'iTXt') {
+      const compressed = rest[0] === 1
+      if (compressed) continue // would need zlib; these cards do not use it
+      rest = rest.subarray(2)
+      const langEnd = rest.indexOf(0)
+      if (langEnd < 0) continue
+      rest = rest.subarray(langEnd + 1)
+      const transEnd = rest.indexOf(0)
+      if (transEnd < 0) continue
+      rest = rest.subarray(transEnd + 1)
+    }
+    return rest.toString('latin1')
+  }
+  return null
+}
+
+/**
+ * Read a PNG character card into the card-JSON shape the rest of the plugin
+ * expects — the same `{name, description, first_mes, data:{extensions}}` object
+ * a `.json` card has.
+ * @param {string} filePath
+ * @returns {object|null}
+ */
+export function readPngCard(filePath) {
+  let buf
+  try {
+    buf = fs.readFileSync(filePath)
+  } catch (_) {
+    return null
+  }
+  const payload = extractCharaPayload(buf)
+  if (!payload) return null
+
+  const decoded = [
+    () => Buffer.from(payload, 'base64').toString('utf8'),
+    () => Buffer.from(payload.replace(/\s+/g, ''), 'base64').toString('utf8'),
+  ]
+  for (const make of decoded) {
+    try {
+      const json = JSON.parse(make())
+      // Some exports wrap the card as `{spec, data}`, others are flat.
+      const data = json.data && json.data.name ? json.data : json
+      if (!data || (!data.name && !data.first_mes && !data.description)) continue
+      return {
+        ...json,
+        data: {
+          ...(json.data || {}),
+          name: data.name || '',
+          description: data.description || '',
+          personality: data.personality || '',
+          scenario: data.scenario || '',
+          first_mes: data.first_mes || '',
+          mes_example: data.mes_example || '',
+          extensions: data.extensions || (json.data && json.data.extensions) || {},
+          character_book: data.character_book || (json.data && json.data.character_book) || null,
+        },
+      }
+    } catch (_) {}
+  }
+  return null
+}
+
+/** Does the file look like a PNG card (by extension)? */
+export function isPngCard(filePath) {
+  return /\.png$/i.test(String(filePath || ''))
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-muv-table",
-  "version": "0.2.4",
-  "description": "MUV 变量表格编辑器 —— 树形变量面板、宏测试浮窗（random/pick/roll）、骰子快捷栏、pick 缓存管理。dsh-muv-engine 的伴生插件",
+  "version": "0.2.7",
+  "description": "MUV 变量表格编辑器 —— 树形变量面板、宏测试浮窗（random/pick/roll）、骰子快捷栏、pick 缓存管理；支持直接读取 SillyTavern PNG 角色卡（含正则脚本、世界书、变量表）。dsh-muv-engine 的伴生插件",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -10,7 +10,7 @@
     "./lib/*": "./lib/*",
     "./package.json": "./package.json"
   },
-  "files": ["lib", "cordis.patch.yml", "CHANGELOG.md"],
+  "files": ["lib", "cordis.patch.yml", "CHANGELOG.md", "README.md", "test-png-card.mjs"],
   "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "muv", "magvarupdate", "tavern", "variable-table"],
   "license": "PolyForm-Noncommercial-Copyleft-1.0.0",
   "dsh": {

package/test-png-card.mjs

@@ -0,0 +1,116 @@
+// Regression for the PNG character-card reader.
+//
+// Run: node test-png-card.mjs
+//
+// The reader is what lets DSH see a SillyTavern card's *original* data —
+// regex scripts, world book, helper scripts. DSH's own `characters.json`
+// keeps only {name, desc, first}, so if this breaks, a card dragged into
+// SillyTavern silently arrives with none of its rendering machinery.
+import { readPngCard, readPngChunks, extractCharaPayload, isPngCard } from './lib/png-card.js'
+import { readdirSync, existsSync } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+let pass = 0, fail = 0
+function check(name, cond, detail) {
+  if (cond) { pass++; console.log('  OK   ' + name) }
+  else { fail++; console.log('  FAIL ' + name + (detail ? '  -> ' + detail : '')) }
+}
+
+console.log('=== PNG 卡解析回归 ===\n')
+
+// 1) Synthesise a PNG so the test does not depend on any particular machine's
+//    card library. Build the smallest valid chunk set with a `chara` tEXt.
+function buildPng(cardObj) {
+  const chunks = []
+  const chunk = (type, data) => {
+    const len = Buffer.alloc(4); len.writeUInt32BE(data.length)
+    const t = Buffer.from(type, 'ascii')
+    const crc = Buffer.alloc(4) // CRC is not validated by the reader
+    return Buffer.concat([len, t, data, crc])
+  }
+  const ihdr = Buffer.alloc(13)
+  ihdr.writeUInt32BE(1, 0); ihdr.writeUInt32BE(1, 4)
+  chunks.push(chunk('IHDR', ihdr))
+  const b64 = Buffer.from(JSON.stringify(cardObj), 'utf8').toString('base64')
+  chunks.push(chunk('tEXt', Buffer.concat([Buffer.from('chara', 'latin1'), Buffer.from([0]), Buffer.from(b64, 'latin1')])))
+  chunks.push(chunk('IEND', Buffer.alloc(0)))
+  return Buffer.concat([Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), ...chunks])
+}
+
+const sampleCard = {
+  name: 'sample',
+  description: 'desc',
+  first_mes: 'hello',
+  data: {
+    name: 'sample',
+    description: 'desc text',
+    first_mes: 'hello there',
+    extensions: {
+      regex_scripts: [{ scriptName: 'a' }, { scriptName: 'b' }],
+      tavern_helper: { scripts: [{ name: 'x' }] },
+    },
+    character_book: { name: 'wb', entries: [{ comment: 'e1' }] },
+  },
+}
+
+console.log('[1] 合成的 PNG 能被解析')
+const buf = buildPng(sampleCard)
+const chunks = readPngChunks(buf)
+check('chunk 遍历出 IHDR/tEXt/IEND', chunks.map(c => c.type).join(',') === 'IHDR,tEXt,IEND', chunks.map(c => c.type).join(','))
+const payload = extractCharaPayload(buf)
+check('chara payload 提取成功', typeof payload === 'string' && payload.length > 10)
+check('payload 是 base64', /^[A-Za-z0-9+/=]+$/.test(payload || ''))
+const decoded = JSON.parse(Buffer.from(payload, 'base64').toString('utf8'))
+check('解出正则数量=2', (decoded.data.extensions.regex_scripts || []).length === 2)
+check('解出世界书', decoded.data.character_book?.entries?.length === 1)
+check('解出 helper 脚本', (decoded.data.extensions.tavern_helper.scripts || []).length === 1)
+
+console.log('\n[2] 不是卡的 PNG 返回 null（不能瞎认）')
+const plainPng = Buffer.concat([
+  Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+  (() => { const l = Buffer.alloc(4); l.writeUInt32BE(13); const t = Buffer.from('IHDR'); const d = Buffer.alloc(13); return Buffer.concat([l, t, d, Buffer.alloc(4)]) })(),
+  (() => { const l = Buffer.alloc(4); l.writeUInt32BE(0); const t = Buffer.from('IEND'); return Buffer.concat([l, t, Buffer.alloc(4)]) })(),
+])
+check('无 chara 块 -> null', extractCharaPayload(plainPng) === null)
+check('垃圾数据不抛异常', (() => { try { extractCharaPayload(Buffer.from('not a png')); return true } catch { return false } })())
+
+console.log('\n[3] isPngCard')
+check('.png 判定', isPngCard('a/b/c.png') === true)
+check('.json 不判定为 png', isPngCard('a.json') === false)
+
+console.log('\n[4] 真实卡库（存在才测，缺失则跳过）')
+function sillyTavernDirs() {
+  const roots = [process.env.DSH_SILLYTAVERN_DIR, 'C:/MySpecialFolder/SillyTavern',
+    path.join(os.homedir(), 'SillyTavern'), path.join(os.homedir(), 'Documents', 'SillyTavern')].filter(Boolean)
+  const out = []
+  for (const root of roots) {
+    const dataDir = path.join(root, 'data')
+    if (!existsSync(dataDir)) continue
+    for (const user of readdirSync(dataDir)) {
+      const chars = path.join(dataDir, user, 'characters')
+      if (existsSync(chars)) out.push(chars)
+    }
+  }
+  return out
+}
+const dirs = sillyTavernDirs()
+let realCards = 0, realWithRegex = 0
+for (const d of dirs) {
+  for (const f of readdirSync(d)) {
+    if (!f.endsWith('.png')) continue
+    const card = readPngCard(path.join(d, f))
+    if (!card) continue
+    realCards++
+    if ((card.data.extensions?.regex_scripts || []).length > 0) realWithRegex++
+  }
+}
+if (realCards === 0) {
+  console.log('  SKIP 未找到 SillyTavern 卡库')
+} else {
+  check('读到真实 PNG 卡 (' + realCards + ' 张)', realCards > 0)
+  check('其中带正则脚本的 (' + realWithRegex + ' 张)', realWithRegex > 0)
+}
+
+console.log(`\n=== 结果: ${pass} 通过, ${fail} 失败 ===`)
+process.exit(fail ? 1 : 0)