cardbuddy 0.23.0 → 0.25.0

package/dist/preview-editor/index.html

@@ -8,8 +8,8 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/favicon-16-Cg6Nrosk.png" />
     <link rel="icon" type="image/png" sizes="32x32" href="/assets/favicon-32-B_1744sp.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/apple-touch-icon-BQcES9QK.png" />
-    <script type="module" crossorigin src="/assets/index-C7N5n_qW.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-7RzNd7tf.css">
+    <script type="module" crossorigin src="/assets/index-DL4ZCJCA.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-MWKPP9nd.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/skills-upgrade.js

@@ -18,12 +18,16 @@
  *   交互环境外（非 TTY）无法确认时，必须带 --force 才能升级，否则明确拒绝并提示（不再
  *   静默跳过、假装升级成功）。
  * 标志：--force/-y 跳过确认直接覆盖；--prune 额外删除 ORPHAN；--dry-run 只报告不落盘。
+ * 依赖检查：升级后探测 skills/ 内 package.json 声明的依赖能否从工程解析，缺失的
+ *   显式给出 `npm install <pkg>` 补装指引（升级不自动装依赖——是否动工程 node_modules
+ *   由用户决定；解析探测与脚本运行时的 Node 解析链一致）。
  * 同步后写 skills/.synced-from = 当前装包版本，供下次 drift 检测与启动提示。
  */
 import fs from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
 import chalk from 'chalk'
 import { loadConfig } from './config.js'
 
@@ -75,6 +79,38 @@ function walkFiles(dir, base = dir, out = []) {
   return out
 }
 
+/**
+ * 收集 skills/ 内各 package.json 声明的依赖中「从其所在目录无法解析」的包名。
+ * 技能脚本运行时按 Node 规则从脚本位置向上找 node_modules（先 skill 自身，再工程根），
+ * 这里用 createRequire 从该 package.json 所在目录模拟同一解析链；解析不到的即缺口——
+ * 升级只拷文件不装依赖，缺口必须显式提示用户补装（0.83.x 事故的教训：
+ * playwright 曾是 optional 依赖静默缺失，脚本运行时才报 Cannot find package）。
+ * @param {string} destSkills 工程内 skills/ 目录
+ * @returns {string[]} 形如 "playwright-core（platform-session-navigator/scripts/package.json）"
+ */
+function collectMissingSkillDeps(destSkills) {
+  const missing = []
+  for (const rel of walkFiles(destSkills)) {
+    if (path.posix.basename(rel) !== 'package.json') continue
+    const pkgPath = path.join(destSkills, rel)
+    let deps
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+      deps = { ...pkg.dependencies, ...pkg.devDependencies }
+    } catch {
+      continue
+    }
+    for (const name of Object.keys(deps)) {
+      try {
+        createRequire(path.join(pkgPath, 'index.js')).resolve(name)
+      } catch {
+        missing.push(`${name}（${rel}）`)
+      }
+    }
+  }
+  return missing
+}
+
 /**
  * 比对源/目标技能树（内容比对）。
  * @returns {{ added:string[], same:string[], modified:string[], orphan:string[] }}
@@ -153,6 +189,25 @@ export async function runSkillsUpgrade({
   const warn = (m) => say(chalk.yellow(`• ${m}`))
   const dim = (m) => say(chalk.dim(`• ${m}`))
 
+  // 依赖在位检查（升级只同步文件、不装依赖，但必须把缺口显式暴露出来）：
+  // 逐个解析 skills/ 内 package.json 声明的依赖，解析不到的给出补装命令。
+  const reportDeps = () => {
+    let missing
+    try {
+      missing = collectMissingSkillDeps(destSkills)
+    } catch {
+      return
+    }
+    if (!missing.length) {
+      dim('技能依赖在位：skills/ 内 package.json 声明的依赖均可从工程解析')
+      return
+    }
+    const names = [...new Set(missing.map((m) => m.slice(0, m.indexOf('（'))))]
+    warn(`⚠ 检测到 ${missing.length} 个技能依赖无法解析（新版本技能可能带来新依赖）：`)
+    for (const m of missing) say(chalk.yellow(`    ${m}`))
+    say(chalk.yellow(`  请在工程根执行：npm install ${names.join(' ')}`))
+  }
+
   if (dryRun) say(chalk.yellow('（dry-run：只报告将要做的事，不落盘）'))
 
   if (!src || !fs.existsSync(src)) {
@@ -169,6 +224,7 @@ export async function runSkillsUpgrade({
 
   if (!diff.added.length && !diff.modified.length && !diff.orphan.length && fs.existsSync(destSkills)) {
     dim(`skills 已是最新（cardbuddy@${version}，无新增 / 修改 / 孤儿）`)
+    reportDeps()
     return 0
   }
 
@@ -240,6 +296,9 @@ export async function runSkillsUpgrade({
     }
   }
 
+  // 依赖在位检查（dry-run 也报，作为升级后的预期状态）
+  reportDeps()
+
   // 汇总
   log('')
   say(chalk.green(dryRun ? 'dry-run 完成（未落盘）' : 'skills 升级完成'))

package/dist/vendored/server/core/browser.js

@@ -35,8 +35,11 @@ let chromiumMod = null
 
 /** 取（惰性启动的）单例浏览器；启动失败会把 browserPromise 复位并抛出 */
 async function getBrowser() {
-  // 动态 import playwright：避免其进入 vite.config 加载图（见文件头注释）
-  if (!chromiumMod) chromiumMod = await import('playwright')
+  // 动态 import playwright-core：避免其进入 vite.config 加载图（见文件头注释）。
+  // 用 playwright-core 而非 playwright：浏览器走系统 Chrome（channel: 'chrome'），
+  // 只需 JS API；playwright 的 postinstall 浏览器下载作为 optional 依赖失败时会被
+  // npm 静默跳过，导致 vendored 发布态运行时报 Cannot find package（0.83.x 事故）。
+  if (!chromiumMod) chromiumMod = await import('playwright-core')
   if (!browserPromise) {
     browserPromise = chromiumMod.chromium
       .launch({ channel: 'chrome', headless: true })
@@ -98,9 +101,9 @@ function serialize(task) {
 
 /**
  * 打开卡片渲染页（chrome=off 纯净模式）并等待首帧稳定。
- * @param {import('playwright').BrowserContext} context
+ * @param {import('playwright-core').BrowserContext} context
  * @param {string} id 卡片 id
- * @returns {Promise<{ page: import('playwright').Page, screen: import('playwright').ElementHandle | null }>}
+ * @returns {Promise<{ page: import('playwright-core').Page, screen: import('playwright-core').ElementHandle | null }>}
  */
 async function openCardScreen(context, id) {
   const page = await context.newPage()

package/dist/vendored/server/core/cardCompile.js

@@ -0,0 +1,202 @@
+/**
+ * 卡片编译端点：把本地 schema.json 编译成两套可投放产物
+ *
+ * POST /__compile-cards  body { cardIds: string[], targetDir?: string }
+ *   → { ok, outDir, cards: [{ id, name, ok, version, templates, nodes, clientBytes, h5Bytes, warnings, error }] }
+ *
+ * 产物布局（客户端 / H5 分两个目录，同属一个父目录）：
+ *   <targetDir>/                    ← 默认 <工程根>/flame-build
+ *     client/<cardCode>/<templateCode>/index.{json,css,databinding,data,js,style}
+ *     h5/<cardCode>.js
+ *     manifest.json                 ← 目录内产物清单（累计）+ 本次编译批次（lastBatch）
+ *
+ * 编译逻辑本身在 flameCompile/ 下（1:1 迁移自 flame-release-mange 的 card/exporter），
+ * 本文件只负责「读盘 → 编译 → 落盘 → 汇报」，不含任何渲染规则。
+ *
+ * 覆盖语义：产物是构建缓存，允许直接覆盖——
+ *   - 逐文件 writeFileSync 截断重写，同卡重复编译结果字节一致；
+ *   - 写之前先删该卡的整个模板目录，模板数量变少（如删掉列表）时不会残留 _sub_/_item；
+ *   - 编译失败不删旧产物（先编译成功再落盘），上一次的好产物不会被半途失败搞坏；
+ *   - manifest 同理不丢信息：按 id 并入已有记录（本次为准），只保留磁盘上仍有产物的卡。
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { compileCard } from './flameCompile/index.js'
+import { log } from './logger.js'
+
+/** 单次编译上限（与导出的 500 同口径） */
+const MAX_COMPILE_CARDS = 500
+
+/** 卡片 id 白名单：只允许字母数字下划线中划线，杜绝目录穿越 */
+const CARD_ID_RE = /^[A-Za-z0-9_-]+$/
+
+/**
+ * 读已有 manifest 的 cards 段。缺失 / 损坏 / 结构不对一律当空数组 ——
+ * 一份旧清单坏掉不该让整批编译失败（它是构建产物，不是输入）。
+ */
+function readPrevManifestCards(manifestPath) {
+  try {
+    const mf = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+    return Array.isArray(mf.cards) ? mf.cards : []
+  } catch {
+    return []
+  }
+}
+
+export function createCompileMiddleware({ root }) {
+  const readJsonBody = (req, res, cb) => {
+    let body = ''
+    req.setEncoding('utf8')
+    req.on('data', (c) => {
+      body += c
+      if (body.length > 1024 * 1024) req.destroy()
+    })
+    req.on('end', () => {
+      try {
+        cb(JSON.parse(body || '{}'))
+      } catch (e) {
+        res.statusCode = 400
+        res.setHeader('Content-Type', 'application/json')
+        res.end(JSON.stringify({ ok: false, error: 'invalid json', message: String(e.message) }))
+      }
+    })
+  }
+
+  const sendJson = (res, status, obj) => {
+    res.statusCode = status
+    res.setHeader('Content-Type', 'application/json')
+    res.setHeader('Cache-Control', 'no-store')
+    res.end(JSON.stringify(obj))
+  }
+
+  return function compileMiddleware(req, res, next) {
+    const pathname = decodeURIComponent((req.url || '').split('?')[0])
+    const method = (req.method || 'GET').toUpperCase()
+    if (pathname !== '/__compile-cards' || method !== 'POST') return next()
+
+    readJsonBody(req, res, (body) => {
+      const rawIds = Array.isArray(body.cardIds)
+        ? body.cardIds.filter((x) => typeof x === 'string')
+        : []
+      // 去重：同一张卡在同一批里传两次没有意义（第二次会把第一次刚写的产物删掉再写一遍），只留首个
+      const ids = [...new Set(rawIds)]
+      if (!ids.length) return sendJson(res, 400, { ok: false, error: 'cardIds 不能为空' })
+      if (ids.length > MAX_COMPILE_CARDS) {
+        return sendJson(res, 400, { ok: false, error: `单次最多编译 ${MAX_COMPILE_CARDS} 张卡片` })
+      }
+
+      const bad = ids.filter((id) => !CARD_ID_RE.test(id))
+      if (bad.length) return sendJson(res, 400, { ok: false, error: `非法卡片 id: ${bad.join(', ')}` })
+
+      // 目标目录：默认工程根下 flame-build；自定义时限制在工程根内，避免误写到系统目录
+      const outDir = body.targetDir
+        ? path.resolve(root, String(body.targetDir))
+        : path.join(root, 'flame-build')
+      const rootResolved = path.resolve(root)
+      if (!outDir.startsWith(rootResolved + path.sep)) {
+        return sendJson(res, 400, { ok: false, error: 'targetDir 必须位于工程目录内' })
+      }
+
+      const clientDir = path.join(outDir, 'client')
+      const h5Dir = path.join(outDir, 'h5')
+      fs.mkdirSync(clientDir, { recursive: true })
+      fs.mkdirSync(h5Dir, { recursive: true })
+
+      const results = []
+      const manifestCards = []
+
+      for (const id of ids) {
+        const schemaPath = path.join(root, 'src', 'cards', id, 'schema.json')
+        if (!fs.existsSync(schemaPath)) {
+          results.push({ id, ok: false, error: 'schema.json 不存在' })
+          continue
+        }
+
+        try {
+          const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'))
+          const compiled = compileCard(schema, { cardCode: id })
+
+          // 清掉该卡的旧产物（模板数量可能变化）
+          const cardClientDir = path.join(clientDir, id)
+          if (fs.existsSync(cardClientDir)) fs.rmSync(cardClientDir, { recursive: true, force: true })
+
+          for (const template of compiled.client) {
+            const dir = path.join(cardClientDir, template.code)
+            fs.mkdirSync(dir, { recursive: true })
+            for (const [file, content] of Object.entries(template.files)) {
+              // index.style 是 SM4 密文（Buffer），必须按字节原样落盘；
+              // 其余是 utf8 文本，显式声明编码便于排查乱码。
+              if (Buffer.isBuffer(content)) fs.writeFileSync(path.join(dir, file), content)
+              else fs.writeFileSync(path.join(dir, file), content, 'utf8')
+            }
+          }
+
+          fs.writeFileSync(path.join(h5Dir, `${id}.js`), compiled.h5, 'utf8')
+
+          results.push({
+            id,
+            ok: true,
+            version: compiled.version,
+            templates: compiled.client.length,
+            nodes: compiled.stats.nodes,
+            clientBytes: compiled.stats.clientBytes,
+            h5Bytes: compiled.stats.h5Bytes,
+            warnings: compiled.warnings,
+          })
+          manifestCards.push({
+            id,
+            name: schema.name || '',
+            version: compiled.version,
+            templates: compiled.client.map((t) => t.code),
+            nodes: compiled.stats.nodes,
+            clientBytes: compiled.stats.clientBytes,
+            h5Bytes: compiled.stats.h5Bytes,
+            warnings: compiled.warnings,
+          })
+        } catch (e) {
+          log.warn(`[compile] ${id} 编译失败: ${e.message}`)
+          results.push({ id, ok: false, error: String(e.message || e) })
+        }
+      }
+
+      const okCount = results.filter((r) => r.ok).length
+      // manifest 描述的是「这个目录里有什么」，因此跨批次累计：按 id 合并，本次记录覆盖同 id 旧记录。
+      // 只按本次批次重写会得到一份自相矛盾的清单——磁盘上 10 张卡，manifest 里只有最后勾的 2 张。
+      // 旧记录还要过一道「磁盘上仍有产物」的存在性检查：换过 targetDir、手工删过文件时它会失真。
+      const manifestPath = path.join(outDir, 'manifest.json')
+      const merged = new Map()
+      for (const c of readPrevManifestCards(manifestPath)) {
+        if (!c || typeof c.id !== 'string' || !c.id) continue
+        const hasArtifacts =
+          fs.existsSync(path.join(clientDir, c.id)) || fs.existsSync(path.join(h5Dir, `${c.id}.js`))
+        if (hasArtifacts) merged.set(c.id, c)
+      }
+      for (const c of manifestCards) merged.set(c.id, c)
+      const manifest = {
+        generatedAt: new Date().toISOString(),
+        outDir,
+        // 目录内卡片总数（累计），不是本批张数
+        count: merged.size,
+        cards: [...merged.values()].sort((a, b) => String(a.id).localeCompare(String(b.id))),
+        // 本次请求的批次结果，便于回溯「这一次又编了什么」
+        lastBatch: {
+          requested: ids.length,
+          ok: okCount,
+          failed: ids.length - okCount,
+          ids,
+        },
+      }
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8')
+
+      log.info(`[compile] 编译完成 ${okCount}/${ids.length} → ${outDir}`)
+      return sendJson(res, 200, {
+        ok: okCount > 0,
+        outDir,
+        clientDir,
+        h5Dir,
+        cards: results,
+      })
+    })
+  }
+}