cardbuddy 0.19.2 → 0.20.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-1exc5zRY.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C_uqjKqI.css">
+    <script type="module" crossorigin src="/assets/index-Dx5hfJ7f.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-08GutEI0.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/skills-upgrade.js

@@ -7,18 +7,22 @@
  * 就是为这个场景而生，且**只动 skills/**，绝不碰 .env.cb / package.json / README.md
  * （那是 `init --force` 的危险面，可能冲掉端口 / FinMall 配置 / AI 网关占位）。
  *
- * 四类 diff（内容比对，非 mtime）：
+ * 行为模型（upgrade = 显式要把新版带进来，「有差异 = 应当覆盖」，不做好坏判定）：
  *   ADDED    源有、目标无        → 复制（安全）
- *   SAME     两边内容一致        → 跳过
- *   MODIFIED 两边都有、内容不同  → 默认跳过 + 黄色警告（覆盖风险：消费者可能改过该 shipped skill）
- *   ORPHAN   目标有、源无        → 默认保留不删（可能是消费者私有 skill，或上游已下架该 skill）
+ *   SAME     两边一致            → 跳过
+ *   MODIFIED 两边都有、内容不同  → 默认覆盖（这正是升级的目的，会丢弃本地副本的改动）
+ *   ORPHAN   目标有、源无        → 默认保留（可能是私有 / 上游已下架）
  *
- * 标志：--force 覆盖 MODIFIED；--prune 额外删除 ORPHAN（危险，需显式）；--dry-run 只报告；
- *       --strict 存在 MODIFIED 且未 --force 时返回非 0（便于 CI 感知未决覆盖）。
+ * 确认门禁：当存在 MODIFIED（将覆盖并丢弃本地改动）时，默认进入交互确认——展示将覆盖的
+ *   文件清单，请用户 [y/N] 确认；确认即覆盖，否认即跳过这些 MODIFIED 并继续其余变更。
+ *   交互环境外（非 TTY）无法确认时，必须带 --force 才能升级，否则明确拒绝并提示（不再
+ *   静默跳过、假装升级成功）。
+ * 标志：--force/-y 跳过确认直接覆盖；--prune 额外删除 ORPHAN；--dry-run 只报告不落盘。
  * 同步后写 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 chalk from 'chalk'
 import { loadConfig } from './config.js'
@@ -95,14 +99,36 @@ export function diffSkills(src, dest) {
   return res
 }
 
+/**
+ * 确认是否覆盖 MODIFIED 文件。
+ * - force/injected confirm：直接给结果（便于非交互 / 测试）
+ * - 交互 TTY：readline 逐条列出后请用户 [y/N]
+ * - 非 TTY 且无 --force：返回 null（调用方据此明确拒绝，而非静默跳过）
+ * @returns {Promise<boolean|null>}
+ */
+async function resolveOverwriteConsent({ modified, force, confirm, log, tag }) {
+  if (force) return true
+  if (typeof confirm === 'function') return Boolean(await confirm(modified))
+  if (!process.stdin.isTTY) return null
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
+  try {
+    log(tag + chalk.yellow(`将覆盖 ${modified.length} 个本地已修改的技能文件（你的本地改动将被丢弃）：`))
+    for (const rel of modified) log(chalk.yellow('    ' + rel))
+    const ans = await rl.question(chalk.bold('确认用包内版本覆盖以上文件？[y/N] '))
+    return /^(y|yes|是|确认|ok)$/i.test(ans.trim())
+  } finally {
+    rl.close()
+  }
+}
+
 /**
  * 执行 skills 升级。
  * @param {object} opts
  * @param {string} [opts.targetDir='.'] 目标工程根（skills 落在 <targetDir>/skills）
- * @param {boolean} [opts.force] 覆盖本地已修改的 shipped skill
+ * @param {boolean} [opts.force] 跳过确认直接覆盖本地已修改的 shipped skill（非交互必备）
  * @param {boolean} [opts.dryRun] 只报告不落盘
  * @param {boolean} [opts.prune] 额外删除包内已不存在的技能文件（默认保留）
- * @param {boolean} [opts.strict] 存在未覆盖 MODIFIED 时返回非 0
+ * @param {(modified:string[])=>boolean|Promise<boolean>} [opts.confirm] 注入式确认（测试用，默认交互）
  * @param {ReturnType<import('./config.js').loadConfig>} [opts.config]
  * @param {(msg: string) => void} [opts.log]
  * @returns {Promise<number>} 进程退出码
@@ -112,7 +138,7 @@ export async function runSkillsUpgrade({
   force = false,
   dryRun = false,
   prune = false,
-  strict = false,
+  confirm = null,
   config,
   log = (m) => console.log(m),
 } = {}) {
@@ -141,13 +167,36 @@ export async function runSkillsUpgrade({
   const version = ownVersion()
   const diff = diffSkills(src, destSkills)
 
+  if (!diff.added.length && !diff.modified.length && !diff.orphan.length && fs.existsSync(destSkills)) {
+    dim(`skills 已是最新（cardbuddy@${version}，无新增 / 修改 / 孤儿）`)
+    return 0
+  }
+
+  // 确认门禁：存在将被覆盖的 MODIFIED 时，先确认
+  let overwriteModified = false
+  if (diff.modified.length && !dryRun) {
+    const consent = await resolveOverwriteConsent({ modified: diff.modified, force, confirm, log, tag })
+    if (consent === null) {
+      warn(`⚠ 检测到 ${diff.modified.length} 个已修改的技能文件将被覆盖，但当前非交互环境无法确认。`)
+      dim('  加 --force 跳过确认直接覆盖，或在交互终端运行本命令确认。')
+      return 1
+    }
+    overwriteModified = consent
+    if (!overwriteModified) {
+      warn(`已跳过 ${diff.modified.length} 个 MODIFIED 文件（未确认覆盖，本地副本保留）；其余变更仍会进行。`)
+    }
+  } else if (diff.modified.length && dryRun) {
+    warn(`dry-run：${diff.modified.length} 个已修改的技能文件将被覆盖（确认后）。`)
+  }
+
   let copied = 0
   let bytes = 0
   let overwritten = 0
+  let added = 0
   let deleted = 0
 
-  // ADDED 总是复制；MODIFIED 仅 --force 时复制
-  const toCopy = [...diff.added, ...(force ? diff.modified : [])]
+  // ADDED 总是复制；MODIFIED 仅当用户确认（或 --force）时复制——这正是升级的目的
+  const toCopy = [...diff.added, ...(overwriteModified ? diff.modified : [])]
   for (const rel of toCopy) {
     const sp = path.join(src, rel)
     const dp = path.join(destSkills, rel)
@@ -159,15 +208,7 @@ export async function runSkillsUpgrade({
     bytes += fs.statSync(sp).size
     copied++
     if (isModified) overwritten++
-  }
-
-  // MODIFIED 未 --force：警告（不复制，防丢改动）
-  if (!force && diff.modified.length) {
-    warn(`⚠ 检测到 ${diff.modified.length} 个已修改的技能文件（本地副本与包内不一致），默认不覆盖，避免丢失你的改动：`)
-    for (const rel of diff.modified) say(chalk.yellow(`    ${rel}`))
-    dim('  如需用包内版本覆盖，加 --force；想先看差异，加 --dry-run 后人工对比。')
-  } else if (force && diff.modified.length) {
-    warn(`--force：已用包内版本覆盖 ${diff.modified.length} 个本地修改的技能文件（你的改动将被丢弃）`)
+    else added++
   }
 
   // ORPHAN：默认保留；--prune 才删除
@@ -207,14 +248,12 @@ export async function runSkillsUpgrade({
   say(chalk.dim(`  目标：${targetNote}`))
   say(
     chalk.dim(
-      `  新增 ${diff.added.length} · 相同 ${diff.same.length} · 覆盖 ${overwritten} · 保留私有 ${diff.orphan.length}` +
+      `  新增 ${added} · 相同 ${diff.same.length} · 覆盖 ${overwritten}` +
+        `${overwriteModified ? '' : ` · 跳过修改 ${diff.modified.length - overwritten}`}` +
+        ` · 保留私有 ${diff.orphan.length}` +
         `${prune ? ` · 删除孤儿 ${deleted}` : ''} · 体积 ${fmtBytes(bytes)}`
     )
   )
 
-  if (strict && diff.modified.length && !force) {
-    say(chalk.red('（--strict：存在未覆盖的 MODIFIED 文件，返回非 0）'))
-    return 2
-  }
   return 0
 }

package/dist/vendored/card-editor/components/MultiColumn.vue

@@ -1,12 +1,13 @@
 <!--
   多列布局容器（官方组件 MultiColumn）。
 
-  预览运行时此前未注册该组件，导致画布显示「未知组件」占位（问题 #4）。
-  本组件对齐 Row/Column 的容器范式：用 StyleParser 解析样式（rect / flex / padding …），
-  渲染默认插槽内容；当 `column` 属性 > 1 时切换为 CSS Grid 多列布局（列数 = column）。
+  官方 component-meta 里 MultiColumn 没有 column 属性（properties: []），
+  真实运行时语义 = **直接子节点数即列数，单行均分**（N 个子节点 → N 等宽列）。
+  预览器此前自造 `column=2` 默认值，导致 4 子节点被排成 2×2（overseaTransfer
+  步骤条 row_hf 实测踩坑：内容高度翻倍后被 AbsoluteLayout 裁切，圆圈/标签错位）。
 
-  说明：当前测试卡的 MultiColumn 实例（comp_3）为「空容器」（无插槽子节点、无 column 属性），
-  此处仍提供完整的多列渲染能力，便于后续接入真实带子节点的多列布局卡片。
+  实现：显式传 column > 0 时按指定列数（保留扩展口子）；否则按默认插槽的
+  子 vnode 数自动取列数，>1 时切换 CSS Grid 单行均分（flex gap 兼作列间距）。
 -->
 <template>
   <div ref="mc" class="ce_multicolumn" :style="styleObj" @click="$emit('click', $event)">
@@ -15,6 +16,7 @@
 </template>
 
 <script>
+import { Comment, Text } from 'vue'
 import StyleParser from '../runtime/StyleParser.js'
 import base from './base.js'
 
@@ -24,16 +26,23 @@ export default {
   mixins: [base],
   props: {
     styleProps: { type: Object, default: () => ({}) },
-    column: { type: [Number, String], default: 2 },
+    /** 列数。0 = 自动（默认）：按子节点数单行均分，对齐官方「无 column 属性」语义 */
+    column: { type: [Number, String], default: 0 },
   },
   computed: {
+    cols() {
+      const explicit = parseInt(this.column, 10)
+      if (explicit > 0) return explicit
+      const vnodes = this.$slots.default ? this.$slots.default() : []
+      // 只统计真实子组件 vnode；注释 / 纯文本节点不计入
+      return vnodes.filter((v) => v && v.type !== Comment && v.type !== Text).length
+    },
     styleObj() {
       const s = new StyleParser(this, this.styleProps).parse()
-      const cols = parseInt(this.column, 10)
-      if (cols && cols > 1) {
-        // 多列：用 grid 把子节点按 column 列均分；flex gap 同时充当 grid 行列间距。
+      if (this.cols > 1) {
+        // 多列：用 grid 把子节点单行均分；flex gap 同时充当 grid 列间距。
         s.display = 'grid'
-        s.gridTemplateColumns = `repeat(${cols}, 1fr)`
+        s.gridTemplateColumns = `repeat(${this.cols}, 1fr)`
       }
       return s
     },

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

@@ -0,0 +1,203 @@
+import { pathToFileURL } from 'node:url'
+import { findCardDir } from './cardSidecar.js'
+import { readImportMeta, markDirty } from './cardImportMeta.js'
+import { writeCardFiles } from './cardFiles.js'
+import { log } from './logger.js'
+import { resolveSkillPathOrProject } from './skillPaths.js'
+
+const SYNC_SCRIPT_REL = 'finmall-card-sync/scripts/api_batch_sync.mjs'
+
+/** 读取 JSON 请求体（1MB 上限防失控） */
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = ''
+    req.on('data', (chunk) => {
+      raw += chunk
+      if (raw.length > 1024 * 1024) {
+        reject(new Error('请求体过大'))
+        req.destroy()
+      }
+    })
+    req.on('end', () => {
+      try {
+        resolve(raw ? JSON.parse(raw) : {})
+      } catch {
+        reject(new Error('请求体不是合法 JSON'))
+      }
+    })
+    req.on('error', reject)
+  })
+}
+
+/**
+ * 调试面板「卡片历史记录」tab 的远端版本时间线（只读）：GET /__card-history/:cardCode
+ *
+ * 语义：经 .import-meta.json 侧车里的 cardId 调 IDC10013，取该卡历史版本列表（新→旧），
+ * 每条含时间 / 预览图（/minio 同源路径）/ 版本记录 id / 相对上一版本的变更标签。
+ * 触发时机由前端控制（切到 tab / 点刷新 / 加载更多），不自动轮询——与「卡片来源」tab
+ * 的懒加载策略一致，避免每次加载卡片都拉起后台 Chrome。
+ *
+ * 恢复端点：POST /__card-history/:cardCode/restore（body { versionId }）——把指定历史
+ * 版本的完整 schema 写入本地 src/cards/<code>/schema.json（原子写 + 派生 data.json），
+ * 并标记 dirty（本地偏离导入镜像；推送成功后自会清除）。watcher 推 SSE、编辑器重载后
+ * 即可继续编辑，经既有「推送」链路（IDC10010）保存为远端最新版本。
+ *
+ * 安全闸（与 /__card-version / /__save 同源）：仅「已同步导入卡」（有 .import-meta.json
+ * 侧车且含 cardId）可操作；本地自建卡 / 未同步卡返回 409 local_card_no_source。
+ * 恢复另有防串卡校验：历史 schema.pageId 必须等于侧车 cardId，否则 409 pageId_mismatch。
+ *
+ * @param {{ root: string }} opts
+ * @returns {(req: import('http').IncomingMessage, res: import('http').ServerResponse, next: Function) => void}
+ */
+export function createCardHistoryMiddleware({ root }) {
+  return function cardHistoryMiddleware(req, res, next) {
+    const pathname = decodeURIComponent((req.url || '').split('?')[0])
+    const mRestore = pathname.match(/^\/__card-history\/([^/]+)\/restore$/)
+    const mList = pathname.match(/^\/__card-history\/([^/]+)$/)
+    if (!mRestore && !mList) return next()
+    const method = (req.method || 'GET').toUpperCase()
+    if (mRestore ? method !== 'POST' : method !== 'GET') return next()
+
+    const id = decodeURIComponent((mRestore || mList)[1])
+    const dir = findCardDir(root, { code: id })
+    const meta = dir ? readImportMeta(dir) : null
+    if (!meta || !meta.cardId) {
+      res.statusCode = 409
+      res.setHeader('Content-Type', 'application/json')
+      return res.end(
+        JSON.stringify({
+          ok: false,
+          error: 'local_card_no_source',
+          message: '该卡片为本地自建、无远端同步来源（缺少 .import-meta.json 侧车），无法查看远端历史。',
+        }),
+      )
+    }
+
+    if (mRestore) return handleRestore(req, res, { root, id, dir, meta })
+    return handleList(req, res, { root, id, meta })
+  }
+}
+
+/** GET 列表：分页参数（query）pageNo / pageSize，缺省 1 / 30，上限 100 防失控 */
+function handleList(req, res, { root, id, meta }) {
+  const qs = new URL(req.url || '/', 'http://localhost').searchParams
+  const pageNo = Math.max(1, parseInt(qs.get('pageNo') || '1', 10) || 1)
+  const pageSize = Math.min(100, Math.max(1, parseInt(qs.get('pageSize') || '30', 10) || 30))
+
+  ;(async () => {
+    try {
+      const skillPath = resolveSkillPathOrProject(root, SYNC_SCRIPT_REL)
+      const { fetchCardHistory } = await import(pathToFileURL(skillPath).href)
+      const r = await fetchCardHistory(meta.cardId, { pageNo, pageSize })
+      log.ok('查询远端卡片历史', { cardCode: id, cardId: String(meta.cardId), count: r.list.length })
+      res.statusCode = 200
+      res.setHeader('Content-Type', 'application/json')
+      res.setHeader('Cache-Control', 'no-store')
+      res.end(
+        JSON.stringify({
+          ok: true,
+          cardId: String(meta.cardId),
+          cardCode: id,
+          list: r.list,
+          totalNums: r.totalNums,
+          totalPages: r.totalPages,
+        }),
+      )
+    } catch (e) {
+      // 区分「凭据缺失」与「真正的查询错误」：前者让前端提示登录，而非裸抛 ENOENT。
+      const isNoCred =
+        e && /credentials\.json|credentials 不存在|NO_CREDENTIALS/.test(String(e && e.message))
+      res.statusCode = isNoCred ? 200 : 500
+      res.setHeader('Content-Type', 'application/json')
+      res.end(
+        JSON.stringify(
+          isNoCred
+            ? { error: 'need_credentials', needCredentials: true, message: String(e && e.message) }
+            : { error: 'history failed', message: String(e && e.message) },
+        ),
+      )
+    }
+  })()
+}
+
+/** POST restore：按 versionId 取历史 schema → 防串卡校验 → 原子写 schema.json + 派生 data.json → 标记 dirty */
+function handleRestore(req, res, { root, id, dir, meta }) {
+  ;(async () => {
+    try {
+      const body = await readJsonBody(req)
+      const versionId = String((body && body.versionId) || '')
+      if (!versionId) {
+        res.statusCode = 400
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(JSON.stringify({ ok: false, error: 'missing_version_id', message: '缺少 versionId（远端版本记录 id）。' }))
+      }
+      const skillPath = resolveSkillPathOrProject(root, SYNC_SCRIPT_REL)
+      const { fetchCardVersionSchema } = await import(pathToFileURL(skillPath).href)
+      let schema
+      let record
+      try {
+        ;({ schema, record } = await fetchCardVersionSchema(meta.cardId, versionId))
+      } catch (e) {
+        // 缓存未命中（时间线未加载过 / TTL 过期 / 目标在更旧页）：先拉一页 100 条预热
+        // (cardId, versionId) 缓存再重试——一页 4.2s，通常快于翻页到命中位置，且覆盖最新
+        // 100 个版本（用户点击的多为时间线可见项）。
+        if (!/找不到版本记录/.test(String(e && e.message))) throw e
+        const { fetchCardHistory } = await import(pathToFileURL(skillPath).href)
+        await fetchCardHistory(meta.cardId, { pageNo: 1, pageSize: 100 })
+        ;({ schema, record } = await fetchCardVersionSchema(meta.cardId, versionId))
+      }
+      // 防串卡：历史 schema 的 pageId 必须等于侧车登记的 cardId（与 /__save 的 pageId 闸门同语义）
+      if (String(schema.pageId) !== String(meta.cardId)) {
+        res.statusCode = 409
+        res.setHeader('Content-Type', 'application/json')
+        return res.end(
+          JSON.stringify({
+            ok: false,
+            error: 'pageId_mismatch',
+            message: `版本记录 #${versionId} 的 schema.pageId（${schema.pageId}）与本地卡片来源（${meta.cardId}）不一致，已拒绝加载。`,
+          }),
+        )
+      }
+      // 原子写 schema.json + 单向派生 data.json（与编辑器本地保存同一写入口）
+      const written = writeCardFiles(dir, { schema })
+      // 本地内容已偏离导入镜像：标记 dirty，来源 tab 可见；推送成功后由 recordExport/markDirty 清除
+      markDirty(dir, true)
+      log.ok('恢复远端历史版本到本地', {
+        cardCode: id,
+        cardId: String(meta.cardId),
+        versionId,
+        createTime: record.createTime,
+        written,
+      })
+      res.statusCode = 200
+      res.setHeader('Content-Type', 'application/json')
+      res.setHeader('Cache-Control', 'no-store')
+      res.end(
+        JSON.stringify({
+          ok: true,
+          cardCode: id,
+          cardId: String(meta.cardId),
+          versionId,
+          createTime: record.createTime,
+          written,
+        }),
+      )
+    } catch (e) {
+      const msg = String(e && e.message)
+      const isNoCred = /credentials\.json|credentials 不存在|NO_CREDENTIALS/.test(msg)
+      const isNotFound = /找不到版本记录|schema 为空或损坏/.test(msg)
+      const status = isNoCred ? 200 : isNotFound ? 404 : 500
+      res.statusCode = status
+      res.setHeader('Content-Type', 'application/json')
+      res.end(
+        JSON.stringify(
+          isNoCred
+            ? { ok: false, error: 'need_credentials', needCredentials: true, message: msg }
+            : isNotFound
+              ? { ok: false, error: 'version_not_found', message: msg }
+              : { ok: false, error: 'restore failed', message: msg },
+        ),
+      )
+    }
+  })()
+}