cardbuddy 0.22.0 → 0.23.0

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

@@ -4,7 +4,7 @@ import path from 'node:path'
 
 /**
  * 远端资源代理：把预览里引用的站内资源路径（@filestore / /minio / /fastdfs …）
- * 回源到 FinMall 上游站点并落盘缓存。所有跨网络回源逻辑集中在本模块维护。
+ * 回源到远端上游站点并落盘缓存。所有跨网络回源逻辑集中在本模块维护。
  */
 
 /**

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

@@ -1,4 +1,4 @@
-import { devApiBase } from '../../tools/finmall-env.mjs'
+import { devApiBase } from '../../tools/platform-env.mjs'
 
 /**
  * 共享浏览器单例 + 卡片页面加载（screenshot.js / bbox.js 共用）。

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

@@ -0,0 +1,324 @@
+/**
+ * 大卡 schema 的**读方向折叠**（structure digest）。
+ *
+ * 为什么需要：`schema.json` 是编辑器持久化格式，单卡紧凑 JSON 实测最大 239KB / 167 节点。
+ * 读大卡时旧行为是「JSON 字符串取前 12000 字符」，而 JSON 的键序是
+ * `version / pageId / name / desc / platform / dictionary / view` —— `dictionary` 排在 view 前面，
+ * 30 条 inputParams 就吃掉 10.5KB。实测 overseaTransfer（239KB / 167 节点）的 12k 切片里
+ * **componentId 出现 0 次**：模型花 12k 字符只拿到参数声明 + 根节点的半张样式表，
+ * 一个组件都没看到，于是转头用 card_grep 反复试路径，白走 2~5 步（每步 20~40k 输入）。
+ *
+ * 同一个 12k 预算下，全节点骨架只要 4.7k：167 行 `componentId(ClassName) 「主文本」`。
+ * 所以折叠的目标不是「少给」，而是**把预算从「前 N 个字节」换成「N 个节点的地图」**：
+ *   - 骨架：全部节点的身份 + 主文本 + 层级（模型据此能点到任何一处）
+ *   - 参数：inputParams 压缩成一行 key:type=default
+ *   - 不给样式与属性全量 —— 要就 `card_read {id, node:"<componentId>"}` 定向取子树
+ *   - 同时给出该子树的真实 JSON 路径，`card_patch` 可直接用，省掉 card_grep 摸索
+ */
+
+/** 骨架里主文本的截断长度：够认人即可，不搬正文 */
+const TEXT_MAX = 24
+/** 层级缩进最多叠到第几层（更深的保持同缩进，防止 30 层缩进把行宽吃光） */
+const DEPTH_INDENT_MAX = 8
+/** 骨架占预算的比例，其余留给参数表 / 元信息 / 下一步指引 */
+const TREE_BUDGET_RATIO = 0.66
+/** 参数表预算上限 */
+const PARAM_BUDGET = 2400
+
+/**
+ * 取节点主值（等价于渲染出来的那段字）。
+ * `itemValueFrom`: 0=常量 / 1=变量 / 2=图片（与 ir-format.md 的 p / v / pi 对应）。
+ * @returns {string} 空串表示该节点没有主值
+ */
+function mainValue(node) {
+  const props = Array.isArray(node.properties) ? node.properties : []
+  for (const p of props) {
+    if (!p || p.itemKey !== 'value') continue
+    const from = String(p.itemValueFrom ?? '0')
+    if (from === '2') return '[图片]'
+    const raw = p.itemValue
+    if (from === '1') {
+      const name = typeof raw === 'string' ? raw : raw && typeof raw === 'object' ? (raw.value ?? raw.key) : ''
+      const s = name ? String(name) : ''
+      if (!s) return '[变量]'
+      // itemValue 本身就形如 `$remark`，不要再补一个 $（曾出现 `$$remark`）
+      return s.startsWith('$') ? s : `$${s}`
+    }
+    if (raw == null || typeof raw === 'object') return ''
+    return String(raw)
+  }
+  return ''
+}
+
+/**
+ * 事件摘要：把 `eventactions[]` 压成 `eventKey:actionType(N字)`，多个逗号分隔。
+ *
+ * 为什么必须进骨架：全库 366 个节点有事件、代码合计 324KB，单卡最多 27.5KB。
+ * 事件是卡片里真正的业务逻辑，却藏在 8 层路径下
+ * （`eventactions[0].action.properties[0].itemValue.code`）。骨架不给这个标记，
+ * 模型拿到 167 行结构图也不知道哪个节点有事件，只能 `jq` 手数路径去扫 ——
+ * 历史日志里同型命令跨 3 张卡出现 12 次以上，每次一整步（20~40k 输入）。
+ *
+ * 只标「有事件 + 什么事件 + 代码多长」，不搬代码本身：读代码走
+ * `card_read {id, node:"<componentId>"}`，那一棵子树才几千字符。
+ * @returns {string} 空串表示该节点无事件
+ */
+function eventSummary(node) {
+  const ea = node && node.eventactions
+  if (!Array.isArray(ea) || !ea.length) return ''
+  const parts = []
+  for (const a of ea) {
+    if (!a || typeof a !== 'object') continue
+    const key = (a.event && a.event.eventKey) || '?'
+    const type = (a.action && a.action.actionType) || '?'
+    const props = Array.isArray(a.action && a.action.properties) ? a.action.properties : []
+    const fn = props.find((p) => p && p.itemKey === 'function')
+    const iv = fn && fn.itemValue
+    // 运行时取 `code || compiled`（见 preview 的 actionCode），长度按同口径算
+    const code = iv && typeof iv === 'object' ? String(iv.code || iv.compiled || '') : ''
+    parts.push(`${key}:${type}${code ? `(${code.length}字)` : ''}`)
+  }
+  return parts.join(',')
+}
+
+/**
+ * 全卡事件代码总字符数（运行时口径 `code || compiled`）。
+ * 只用于 meta 报规模，帮模型判断「要不要一次读完」。
+ */
+function countEventChars(view) {
+  let total = 0
+  const walk = (n) => {
+    if (!n || typeof n !== 'object') return
+    const ea = n.eventactions
+    if (Array.isArray(ea)) {
+      for (const a of ea) {
+        const props = Array.isArray(a && a.action && a.action.properties) ? a.action.properties : []
+        const fn = props.find((p) => p && p.itemKey === 'function')
+        const iv = fn && fn.itemValue
+        if (iv && typeof iv === 'object') total += String(iv.code || iv.compiled || '').length
+      }
+    }
+    for (const c of n.components || []) walk(c)
+    for (const sl of n.slots || []) for (const c of (sl && sl.components) || []) walk(c)
+  }
+  walk(view)
+  return total
+}
+
+/**
+ * 子节点列表，带**可直接用于 card_patch 的真实 JSON 点路径**。
+ * 节点树是 `view.components[]` 与 `view.slots[].components[]` 两种容器，不是 `view.children`。
+ * @returns {Array<{node: object, path: string}>}
+ */
+function childEntries(node, nodePath) {
+  const out = []
+  if (Array.isArray(node.components)) {
+    node.components.forEach((c, i) => {
+      if (c && typeof c === 'object') out.push({ node: c, path: `${nodePath}.components.${i}` })
+    })
+  }
+  if (Array.isArray(node.slots)) {
+    node.slots.forEach((sl, j) => {
+      const inner = Array.isArray(sl && sl.components) ? sl.components : []
+      inner.forEach((c, k) => {
+        if (c && typeof c === 'object') out.push({ node: c, path: `${nodePath}.slots.${j}.components.${k}` })
+      })
+    })
+  }
+  return out
+}
+
+/** 深度优先遍历，产出行列表（带真实路径） */
+function flatten(view) {
+  const rows = []
+  const walk = (node, nodePath, depth) => {
+    const v = mainValue(node)
+    rows.push({
+      depth,
+      cid: typeof node.componentId === 'string' ? node.componentId : '',
+      cls: typeof node.className === 'string' ? node.className : '',
+      text: v ? v.slice(0, TEXT_MAX) : '',
+      events: eventSummary(node),
+      path: nodePath,
+    })
+    for (const e of childEntries(node, nodePath)) walk(e.node, e.path, depth + 1)
+  }
+  walk(view, 'view', 0)
+  return rows
+}
+
+/** 骨架单行渲染（缩进=层级；componentId(className) 「主文本」 ⚡事件） */
+function renderRow(r) {
+  const indent = '  '.repeat(Math.min(r.depth, DEPTH_INDENT_MAX))
+  // 根节点通常没有 componentId，别渲染成 `(无id)(Root)` 这种噪音
+  const head = r.cid ? `${r.cid}(${r.cls})` : r.cls || '(无类名)'
+  const ev = r.events ? ` ⚡${r.events}` : ''
+  return `${indent}${head}${r.text ? ` 「${r.text}」` : ''}${ev}`
+}
+
+/**
+ * inputParams 压成一行 `key:type=default`。
+ * 富字段（rule / children / desc）不进 —— 需要结构化细节时读 node 或 fs_read data.json。
+ * 只给**标量**默认值：对象/数组默认值是 mock 数据（实测 `myCardList` 一条就 400 字符），
+ * 它要的是「存在」而不是「内容」，全搬进来等于把 dictionary 换个地方重新塞满预算。
+ */
+function renderParams(inputParams, budget = PARAM_BUDGET) {
+  const list = Array.isArray(inputParams) ? inputParams : []
+  const parts = []
+  let used = 0
+  let listed = 0
+  for (const p of list) {
+    if (!p || typeof p !== 'object') continue
+    const key = String(p.key ?? '')
+    if (!key) continue
+    const type = String(p.type ?? 'any')
+    const def = p.defaultValue
+    const isScalar = typeof def === 'string' || typeof def === 'number' || typeof def === 'boolean'
+    let suffix = ''
+    if (isScalar && def !== '') {
+      const shown = typeof def === 'string' && def.length > 24 ? `${def.slice(0, 24)}…` : def
+      suffix = `=${JSON.stringify(shown)}`
+    }
+    const seg = `${key}:${type}${suffix}`
+    if (used + seg.length + 2 > budget) break
+    parts.push(seg)
+    used += seg.length + 2
+    listed++
+  }
+  const more = list.length - listed
+  return {
+    text: parts.join(', ') + (more > 0 ? `, …（另有 ${more} 个未列出，用 fs_read data.json 看全量）` : ''),
+    listed,
+    total: list.length,
+  }
+}
+
+/**
+ * 生成大卡结构摘要。
+ * @param {object} schema 完整 schema 对象
+ * @param {object} data 派生 data（用于参数表兜底；通常与 inputParams.defaultValue 一致）
+ * @param {{id?: string, budget?: number}} opts budget ≈ 该工具结果的字符档位
+ * @returns {{meta: object, tree: string, treeTruncated: boolean, params: string, next: string[]}|null}
+ */
+export function digestCard(schema, data, { id = '', budget = 12000 } = {}) {
+  const view = schema && typeof schema.view === 'object' ? schema.view : null
+  if (!view) return null
+  const rows = flatten(view)
+  const compactBytes = JSON.stringify(schema).length
+  const treeBudget = Math.max(1200, Math.floor(budget * TREE_BUDGET_RATIO))
+
+  const lines = []
+  let used = 0
+  let listed = 0
+  for (const r of rows) {
+    const line = renderRow(r)
+    // 留 1 字节给换行；超预算即停（宁可少列，也不让骨架本身被 clipToolResult 二次腰斩）
+    if (used + line.length + 1 > treeBudget) break
+    lines.push(line)
+    used += line.length + 1
+    listed++
+  }
+  const truncated = listed < rows.length
+
+  // 截断时补一段「被截掉的区块分布」：不列全文，但让模型知道还有哪些区域、各多少节点，
+  // 从而能直接 node 定向读，而不是重新猜。
+  let restNote = ''
+  if (truncated) {
+    const rest = rows.slice(listed)
+    const byCls = new Map()
+    for (const r of rest) {
+      const k = `${r.cls}`
+      byCls.set(k, (byCls.get(k) || 0) + 1)
+    }
+    const dist = [...byCls].sort((a, b) => b[1] - a[1]).slice(0, 12).map(([k, n]) => `${k}×${n}`).join(' ')
+    // 事件节点尤其要点名：截断区里的事件是「看不见但一定要改」的那部分
+    const restEv = rest.filter((r) => r.events)
+    const evNote = restEv.length
+      ? `\n其中 ${restEv.length} 个节点带事件：${restEv.slice(0, 10).map((r) => `${r.cid || '(根)'}[${r.events}]`).join(' ')}${restEv.length > 10 ? ' …' : ''}`
+      : ''
+    restNote =
+      `\n… 还有 ${rest.length} 个节点未列出（已达骨架预算）。它们的组件分布：${dist}${evNote}` +
+      `\n用 card_read {id:"${id}", node:"<componentId>"} 定向读某棵子树；` +
+      `未列出的组件 id 可用 card_grep 按文案/类名查，或 fs_read schema.json 按 offset 续读。`
+  }
+
+  const params = renderParams(schema?.dictionary?.inputParams)
+  const evRows = rows.filter((r) => r.events)
+  const evChars = countEventChars(view)
+  const next = [
+    `**带 ⚡ 标记的节点有事件**（click / onReady / onMeasured…），圆括号里是代码字符数；读它 → card_read {id:"${id}", node:"<componentId>"}，返回该子树含完整 JS（比整卡小一到两个数量级）`,
+    `改值/改样式/改事件 → card_patch {id:"${id}", patches:[{path:"@<componentId>/eventactions.0.action.properties.0.itemValue.code", value:"…"}]}；@ 前缀自动解析成真实 JSON 路径，不用先 card_grep；写 code 时 compiled 会自动同步，不必手写第二份`,
+    `看某节点的样式/属性 → card_read {id:"${id}", node:"<componentId>"}`,
+    `要看原文 → fs_read {"path":"src/cards/${id}/schema.json","offset":<字节偏移>}`,
+  ]
+
+  return {
+    meta: {
+      id,
+      pageId: schema?.pageId ?? '',
+      platform: schema?.platform ?? '',
+      root: view.className || '',
+      nodes: rows.length,
+      nodesListed: listed,
+      compactBytes,
+      /** 有事件的节点数 / 事件代码总字符（不含在白给的 tree 里，要按 node 定向读） */
+      eventNodes: evRows.length,
+      eventChars: evChars,
+    },
+    tree: lines.join('\n') + restNote,
+    treeTruncated: truncated,
+    params: params.text,
+    next,
+    hasData: !!(data && typeof data === 'object' && Object.keys(data).length),
+  }
+}
+
+/**
+ * 按 componentId 找节点，返回它的真实 JSON 路径与祖先链。
+ * @returns {{path: string, node: object, depth: number, ancestors: Array<{cid: string, cls: string, path: string}>}|null}
+ */
+export function findNodeByComponentId(schema, componentId) {
+  const view = schema && typeof schema.view === 'object' ? schema.view : null
+  const want = String(componentId || '')
+  if (!view || !want) return null
+  let hit = null
+  const walk = (node, nodePath, depth, ancestors) => {
+    if (hit) return
+    if (node.componentId === want) {
+      hit = { path: nodePath, node, depth, ancestors: ancestors.slice() }
+      return
+    }
+    const chain = depth === 0 ? [] : ancestors
+    for (const e of childEntries(node, nodePath)) {
+      walk(e.node, e.path, depth + 1, [...chain, { cid: node.componentId || '', cls: node.className || '', path: nodePath }])
+      if (hit) return
+    }
+  }
+  walk(view, 'view', 0, [])
+  return hit
+}
+
+/**
+ * 把 `@<componentId>` 开头的路径解析成真实 JSON 点路径。
+ * 支持三种写法：
+ *   `@text_dw`                    → 节点自身路径
+ *   `@text_dw/s.properties`       → 用 `/` 分隔相对段（推荐：componentId 本身可能含 `.`？实际不会，
+ *                                    但相对段里全是数字下标与字段名，用 `/` 更不易歧义）
+ *   `@text_dw.properties.0...`    → 用 `.` 续写相对段
+ * 找不到组件时抛错（响亮失败，不静默新建分支）。
+ * @returns {string} 真实点路径
+ */
+export function resolveComponentPath(schema, atPath) {
+  const s = String(atPath || '')
+  if (!s.startsWith('@')) return s
+  const body = s.slice(1)
+  // componentId 的合法字符集是字母数字 _ -，遇到首个 `/` 或 `.` 就断开
+  const m = body.match(/^([A-Za-z0-9_-]+)(.*)$/)
+  if (!m) throw new Error(`@ 路径缺少 componentId：${s}`)
+  const cid = m[1]
+  const rest = m[2].replace(/^\//, '').replace(/^\./, '')
+  const found = findNodeByComponentId(schema, cid)
+  if (!found) throw new Error(`找不到 componentId=${cid}；先用 card_read 看结构图，或 card_grep 按文案定位`)
+  if (!rest) return found.path
+  return `${found.path}.${rest}`
+}

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

@@ -10,7 +10,7 @@ import { resolveCardDir } from './cardOpenFolder.js'
 /**
  * 卡片导出端点（编辑器「卡片网格预览 → 勾选 → 导出」的服务端实现）。
  *
- * 产物契约（对桌面两份 FinMall 导出样本的逆向结论，详见
+ * 产物契约（对桌面两份远端导出样本的逆向结论，详见
  * docs/卡片导出产物逆向分析与导出功能.md）：
  *   <targetDir>/<yyMMddHHmmss+4位序号>/        ← 临时文件夹（完成后删除）
  *     cards.json                               ← 卡片清单（cardPO 数组，殿后写入）
@@ -49,7 +49,7 @@ const EXPORT_JOB_TIMEOUT_MS = Number(process.env.CARDBUDDY_EXPORT_JOB_TIMEOUT_MS
 /** 图片下载超时（与资源代理回源超时同口径） */
 const IMAGE_FETCH_TIMEOUT_MS = 12000
 
-/** 封面候选扩展名（与 finmall-card-sync 的 findExistingCover 同集） */
+/** 封面候选扩展名（与 platform-card-sync 的 findExistingCover 同集） */
 const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg'])
 
 /**
@@ -60,7 +60,7 @@ const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.
  */
 const COVER_FILESTORE_PREFIX = '@filestore/dzqd-download'
 
-/** 平台状态常量：两份样本恒为三端全平台（与 FinMall 发布接口默认平台集一致） */
+/** 平台状态常量：两份样本恒为三端全平台（与远端发布接口默认平台集一致） */
 const PLATFORM_STATUS = ['iOS', 'Android', 'HarmonyOS']
 
 /** 最小合法骨架屏 SVG：样本为线上编辑器按布局生成，本地不做布局推测，占位保证字段非空 */
@@ -255,7 +255,7 @@ function stampFolderName(targetDir, now = new Date()) {
   return base + Math.random().toString(36).slice(2, 6).padStart(4, '0')
 }
 
-/** 找本地封面预览图（<cardId>.<ext>）；没有返回 null（与 finmall-card-sync 同规则） */
+/** 找本地封面预览图（<cardId>.<ext>）；没有返回 null（与 platform-card-sync 同规则） */
 function findExistingCover(cardDir, id) {
   let entries = []
   try {
@@ -639,7 +639,7 @@ async function exportOneCard({ root, id, outDir, upstream, buildPreview }) {
         fs.copyFileSync(src, dest)
       } else {
         const url = filestoreUrlFor(ref, upstream)
-        if (!url) throw new Error('未配置 FinMall 上游地址，无法下载 @filestore 图片')
+        if (!url) throw new Error('未配置远端上游地址，无法下载 @filestore 图片')
         const res = await fetch(url, {
           headers: { 'User-Agent': 'Mozilla/5.0', Referer: upstream ? `${upstream}/` : '' },
           signal: AbortSignal.timeout(IMAGE_FETCH_TIMEOUT_MS),

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

@@ -14,7 +14,7 @@ import { buildDataFromSchema } from './buildDataFromSchema.js'
  * 空白卡必须显式归零压掉注入，否则新卡自带隐性间距且属性面板显示「未设置」。
  * 形状取自存量卡根节点（见 style-meta.json：marginType / paddingType，'0' = 全边统一值）。
  * 同一形状还有两份内联副本（禁跨包 import）：skills/dsl-card-generator lib/scaffold.mjs、
- * skills/finmall-card-sync api_batch_sync.mjs 的 buildBlankSchema —— 改这里必须同步改那两处。
+ * skills/platform-card-sync api_batch_sync.mjs 的 buildBlankSchema —— 改这里必须同步改那两处。
  */
 function blankResetStyle() {
   return {

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

@@ -5,7 +5,7 @@ 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'
+const SYNC_SCRIPT_REL = 'platform-card-sync/scripts/api_batch_sync.mjs'
 
 /** 读取 JSON 请求体（1MB 上限防失控） */
 function readJsonBody(req) {

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

@@ -45,7 +45,7 @@ export function buildImportMeta({ baseUrl, appId, workspaceId, cardId, cardCode,
     // 推文件名去读卡目录根的封面，picUrl 为空会退化成目录路径、直接抛异常。真值只在同步时可获得。
     remote: remote || null,
     syncedAt: new Date().toISOString(),
-    tool: 'finmall-card-sync',
+    tool: 'platform-card-sync',
     dirty: false, // 本地编辑后偏离导入镜像为 true（重置为导入镜像后回 false）
     lastExport: null, // 远端保存（/__save）后写入校验结果
     editedAt: null, // 最近一次本地编辑时间（每次写盘都更新），供「按修改时间排序」

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

@@ -1,26 +1,61 @@
 /**
  * 远端卡片列表缓存（dev server 进程内单例）。
  *
- * 用途：推送（保存 / 预览）前确认目标卡片确实存在于 FinMall 卡片列表中，
+ * 用途：推送（保存 / 预览 / 发布）前确认目标卡片确实存在于远端卡片列表中，
  * 拦截「推到已删除 / pageId 错位的卡片」这类风险。
  *
  * 数据来源：IDC10001 卡片列表（与同步同一份数据）。刷新时机由同步逻辑触发——
  * 全量同步（无 cardCode 过滤）时整体替换；单卡同步时增量合并，避免清空其他卡片。
  * 列表条目字段：cardId（数字型，等于 schema.pageId）、code（英文卡 id）、cardName。
  *
- * 单例性：本模块被 server/* 与 skills/finmall-card-sync 以相同绝对路径 import，
+ * app 上下文：列表内容随 appId / workspaceId 而异（同一 baseUrl 下多个应用各有
+ * 独立卡片列表）。开发中途切换 .env.cb 的 appId 后，旧 app 的缓存对当前环境
+ * 完全无意义——若不失效，存在性闸门会拿旧 app 的列表误判新 app 的卡片
+ * 「不在远端列表中」。因此：
+ *   - refreshCardList 写入时盖 appId 戳；发现 appId 变化即清空旧缓存（无论 full 与否）；
+ *   - checkPushAllowed 带上当前 appId 比对，缓存属于另一 app 时视为「未同步」放行。
+ *
+ * 单例性：本模块被 server/* 与 skills/platform-card-sync 以相同绝对路径 import，
  * 在同一 dev server 进程内共享同一份内存，故同步写入、推送读取天然一致。
  */
 
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { skillsCandidates } from './skillPaths.js'
+
 const cardIndex = new Map(); // cardId(String) -> { cardId, code, cardName }
 
+/** 缓存当前所属的远端环境（由最近一次 refreshCardList 盖戳）。 */
+const cacheCtx = { appId: null, workspaceId: null };
+
+/**
+ * 最近一次「全量同步」所属的 appId。存在性闸门只在「当前 appId == 最近全量同步的
+ * appId」时才有判离权：增量合并（单卡同步）只会让列表更片面，片面列表永远不能
+ * 证明「卡片不在远端」——拿它做存在性判断就是刻舟求剑。
+ */
+let fullSyncedAppId = null;
+
 /**
  * 写入/合并卡片列表。
  * @param {Array<{cardId:string|number, code?:string, cardName?:string}>} cards
- * @param {{ full?: boolean }} [opts] full=true 时整体替换（先清空），否则增量合并。
+ * @param {{ full?: boolean, appId?: string|number, workspaceId?: string|number }} [opts]
+ *   full=true 时整体替换（先清空），否则增量合并；
+ *   appId 与缓存戳不一致（环境切换）时无条件清空——旧 app 的列表条目不可复用；
+ *   仅 full=true 才更新 fullSyncedAppId（增量合并不赋予闸门判离权）。
  */
-export function refreshCardList(cards, { full = false } = {}) {
-  if (full) cardIndex.clear();
+export function refreshCardList(cards, { full = false, appId = null, workspaceId = null } = {}) {
+  const ctxChanged =
+    appId != null && cacheCtx.appId != null && String(cacheCtx.appId) !== String(appId);
+  if (full || ctxChanged) {
+    cardIndex.clear();
+    if (ctxChanged) fullSyncedAppId = null; // 换了环境，旧的全量结论作废
+  }
+  if (appId != null) {
+    cacheCtx.appId = String(appId);
+    cacheCtx.workspaceId = workspaceId == null ? null : String(workspaceId);
+  }
+  if (full && appId != null) fullSyncedAppId = String(appId);
   for (const c of cards || []) {
     if (c == null || c.cardId == null) continue;
     const id = String(c.cardId);
@@ -35,17 +70,64 @@ export function hasCardId(cardId) {
 
 /**
  * 推送前存在性校验：目标卡片是否确实在远端卡片列表中（按 cardId/pageId 查）。
- * - 缓存为空（本次 dev server 尚未全量同步过）：放行，返回 allowed=true，避免误拦截首推。
- * - 命中：allowed=true。
- * - 未命中：allowed=false，reason 给出拦截说明（疑似已删除 / pageId 错位）。
+ * - 缓存为空（本次 dev server 尚未同步过）：放行，避免误拦截首推。
+ * - 当前 appId 从未做过全量同步（或中途切换过环境）：缓存片面 / 不可判，放行并标记
+ *   notFullSynced / staleContext=true（调用方可据此记日志提示）。
+ * - 命中：放行。
+ * - 未命中（且当前 appId 有全量列表背书）：拒绝，reason 给出拦截说明。
  * @param {string|number} pageId
- * @returns {{ allowed: boolean, reason: string }}
+ * @param {{ appId?: string|number }} [ctx] 当前生效的远端环境（来自 platform-config）
+ * @returns {{ allowed: boolean, reason: string, staleContext?: boolean, notFullSynced?: boolean }}
  */
-export function checkPushAllowed(pageId) {
+export function checkPushAllowed(pageId, { appId = null } = {}) {
   if (cardIndex.size === 0) return { allowed: true, reason: '' };
+  if (appId != null && String(appId) !== fullSyncedAppId) {
+    const staleContext =
+      cacheCtx.appId != null && String(cacheCtx.appId) !== String(appId);
+    return {
+      allowed: true,
+      reason: '',
+      staleContext: staleContext || undefined,
+      notFullSynced: !staleContext || undefined,
+    };
+  }
   if (hasCardId(pageId)) return { allowed: true, reason: '' };
   return {
     allowed: false,
     reason: `卡片 pageId=${pageId} 不在远端卡片列表中，疑似已删除或 pageId 错位，请先「远程同步」刷新列表后再推送`,
   };
 }
+
+/**
+ * 读取当前工程生效的远端环境（appId / workspaceId），供推送闸门做上下文比对。
+ * 从项目 skills/shared/platform-config.mjs 动态加载（三态解析，优先项目根下的
+ * skills/——其内部按自身位置向上找 .env.cb，读到的正是当前工程生效值）。
+ * 进程内按 root 记忆化：配置在 dev server 生命周期内视为不变（改 .env 需重启服务）。
+ * @param {string} root 项目根
+ * @returns {Promise<{ appId: string|null, workspaceId: string|null }>}
+ */
+const _ctxPromises = new Map();
+export function currentAppContext(root) {
+  const key = String(root || '');
+  if (!_ctxPromises.has(key)) {
+    _ctxPromises.set(
+      key,
+      (async () => {
+        for (const dir of skillsCandidates(root)) {
+          const p = path.join(dir, 'shared', 'platform-config.mjs');
+          if (!fs.existsSync(p)) continue;
+          try {
+            const m = await import(pathToFileURL(p).href);
+            const c = m.platformConfig || {};
+            return {
+              appId: c.appId != null ? String(c.appId) : null,
+              workspaceId: c.workspaceId != null ? String(c.workspaceId) : null,
+            };
+          } catch { /* 读下一个候选 */ }
+        }
+        return { appId: null, workspaceId: null };
+      })(),
+    );
+  }
+  return _ctxPromises.get(key);
+}

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

@@ -2,23 +2,23 @@ import path from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { assertRemoteSource, findCardDir } from './cardSidecar.js'
 import { commitCardChanges } from './cardGitCommit.js'
-import { checkPushAllowed } from './cardListCache.js'
+import { checkPushAllowed, currentAppContext } from './cardListCache.js'
 import { log } from './logger.js'
 import { resolveSkillPathOrProject } from './skillPaths.js'
 
 /**
- * finmall-card-sync 的批量同步脚本（发布复用），相对 skills/
+ * platform-card-sync 的批量同步脚本（发布复用），相对 skills/
  * 与 cardSync.js 同款定位：发布只用到其中的 publishCard。
  */
-const SYNC_SCRIPT_REL = 'finmall-card-sync/scripts/api_batch_sync.mjs'
+const SYNC_SCRIPT_REL = 'platform-card-sync/scripts/api_batch_sync.mjs'
 
 /**
  * 顶栏「远端 → 卡片发布」的服务端处理：取远端最大版本号 +1 后发布上线（IDC10004 → IDC10016）。
- * 复用 finmall-card-sync 的 publishCard（与「同步」「保存远端」「预览」共用同一后台 FinMall 会话）。
+ * 复用 platform-card-sync 的 publishCard（与「同步」「保存远端」「预览」共用同一后台远端会话）。
  *
  * 安全闸（与 /__preview 一致）：
  *   - assertRemoteSource：本地自建、无 .import-meta.json 侧车的卡一律禁止发布，
- *     避免把测试数据误发布到 FinMall 服务器。
+ *     避免把测试数据误发布到远端服务器。
  *   - checkPushAllowed：卡片须存在于远端列表缓存（全量同步时刷新）；缓存为空（尚未同步）则放行。
  *
  * 发布成功后的收尾：把该卡目录（src/cards/<code>/）的未提交变更提交为一条
@@ -64,8 +64,13 @@ export function createPublishMiddleware({ root }) {
         }
       }
       // 存在性闸门：发布前确认目标卡片在远端卡片列表缓存中（为空说明尚未同步，放行）。
+      // 缓存带 appId 戳：环境切换后旧 app 的缓存自动失效放行，不再误判「不在远端列表」。
       {
-        const allow = checkPushAllowed(payload.schema.pageId)
+        const ctx = await currentAppContext(root)
+        const allow = checkPushAllowed(payload.schema.pageId, ctx)
+        if (allow.staleContext || allow.notFullSynced) {
+          log.warn('远端列表缓存对当前 appId 不可判（环境已切换或未全量同步），存在性闸门放行；建议先「远程同步」刷新当前环境列表', { ...ctx, staleContext: !!allow.staleContext })
+        }
         if (!allow.allowed) {
           res.statusCode = 409
           res.setHeader('Content-Type', 'application/json')

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

@@ -4,7 +4,7 @@ import { readImportMeta } from './cardImportMeta.js'
 import { log } from './logger.js'
 import { resolveSkillPathOrProject } from './skillPaths.js'
 
-const SYNC_SCRIPT_REL = 'finmall-card-sync/scripts/api_batch_sync.mjs'
+const SYNC_SCRIPT_REL = 'platform-card-sync/scripts/api_batch_sync.mjs'
 
 /**
  * 调试面板「导入信息」tab「发布版本记录」弹框的远端数据源：
@@ -248,13 +248,13 @@ function handleStopPublish({ root, cardCode, req, res }) {
             message: raw,
           })
         }
-        // finmallPost 抛出的是「FinMall 交易失败 [errorCode=IMVM0005] 状态修改失败 | {整包 JSON}」，
+        // platformPost 抛出的是「远端交易失败 [errorCode=IMVM0005] 状态修改失败 | {整包 JSON}」，
         // 整包塞进 toast 读不过来：这里只取 errorMsg + code，其余留日志。
         log.error('停止远端发布失败', { cardCode, versionId, taskId, error: raw.slice(0, 300) })
         sendJson(res, 500, {
           ok: false,
           error: 'stop_publish_failed',
-          message: finmallErrorMessage(raw, '远端拒绝了本次停止操作'),
+          message: platformErrorMessage(raw, '远端拒绝了本次停止操作'),
         })
       }
     })()
@@ -368,7 +368,7 @@ function handlePublishVersion({ root, cardCode, req, res }) {
         sendJson(res, 500, {
           ok: false,
           error: 'publish_failed',
-          message: finmallErrorMessage(raw, '远端拒绝了本次发布'),
+          message: platformErrorMessage(raw, '远端拒绝了本次发布'),
         })
       }
     })()
@@ -376,12 +376,12 @@ function handlePublishVersion({ root, cardCode, req, res }) {
 }
 
 /**
- * 把 finmallPost 抛出的原始错误压成一句可读文案。
- * 原始形态：「FinMall 交易失败 [errorCode=IMVM0005] 状态修改失败 | {整包 JSON}」——
+ * 把 platformPost 抛出的原始错误压成一句可读文案。
+ * 原始形态：「远端交易失败 [errorCode=IMVM0005] 状态修改失败 | {整包 JSON}」——
  * 整包 JSON 塞进 toast 读不过来，只取 errorMsg + code，其余由调用方写日志。
  */
-function finmallErrorMessage(raw, fallback) {
-  const m = String(raw || '').match(/FinMall 交易失败 \[errorCode=([^\]]+)\]\s*([^|]*)/)
+function platformErrorMessage(raw, fallback) {
+  const m = String(raw || '').match(/远端交易失败 \[errorCode=([^\]]+)\]\s*([^|]*)/)
   if (!m) return raw
   return `${(m[2] || '').trim() || fallback}（${m[1]}）`
 }