#!/usr/bin/env node
// release-check.mjs — 发布前自检（npm prepublishOnly / CI / 手动）
//
// 四道闸：
//   1) 语法校验：dsh/*.mjs + 构建脚本 + 本文件
//   2) 模板平衡：面板 HTML 里的 <script> 不受 node --check 保护（见 .github/scripts/template-balance.mjs）
//   3) 泄漏扫描：按 npm pack 清单 + git 跟踪的文档，拦本机路径 / 私钥 / 访问令牌 / 机器码
//   4) 版本一致性：package.json == PLUGIN_VERSION == 最新 git tag
//
// 用法：
//   node release-check.mjs                    # 发布前（tag 必须已打）
//   node release-check.mjs --allow-untagged    # CI 在未打 tag 的 commit 上跑
//
// 维护者的私人 deny-list（机器码、历史账号、真实用户名）**不入库**，写在同目录
// release-check.local.json：{ "patterns": ["2d12xxxx", "DHC-xxxx", "your-account"] }
// 这样公开仓库本身不含任何真实标识，而本机仍能拦住自己的隐私。
import { readFileSync, existsSync, statSync, readdirSync } from 'node:fs'
import { execFileSync } from 'node:child_process'
import { fileURLToPath } from 'node:url'
import { dirname, join, relative } from 'node:path'
import { wrapClient, sourceFingerprint } from './dsh/client-wrap.mjs'

const root = dirname(fileURLToPath(import.meta.url))
const allowUntagged = process.argv.includes('--allow-untagged')
const fail = (msg) => { console.error('❌ release-check: ' + msg); process.exit(1) }
const warn = (msg) => console.warn('⚠️  ' + msg)
const ok = (msg) => console.log('✅ ' + msg)
const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'

// ── 1. 语法校验 ──
const checkFiles = [
  ...readdirSync(join(root, 'dsh')).filter((f) => f.endsWith('.mjs')).map((f) => 'dsh/' + f),
  'build-client.mjs',
  'release-check.mjs',
  '.github/scripts/template-balance.mjs',
]
for (const f of checkFiles) {
  const p = join(root, f)
  if (!existsSync(p)) { warn('跳过（不存在）: ' + f); continue }
  try { execFileSync(process.execPath, ['--check', p], { stdio: 'pipe' }) } catch (e) {
    fail(`语法错误 ${f}: ${String(e.stderr || e.message).slice(0, 300)}`)
  }
}
ok(`语法校验通过（${checkFiles.filter((f) => existsSync(join(root, f))).length} 个文件）`)

// ── 2. 模板平衡（面板 HTML 内嵌 <script>） ──
try {
  const out = execFileSync(process.execPath, [join(root, '.github/scripts/template-balance.mjs')], { cwd: root, encoding: 'utf8' })
  const last = out.trim().split('\n').pop()
  ok('模板平衡 ' + String(last).replace(/^✅\s*/, ''))
} catch (e) {
  fail('模板平衡自检失败（面板 JS 括号/标签不平衡，运行时会白屏）:\n' + String(e.stdout || '').slice(-500) + String(e.stderr || '').slice(-500))
}

// ── 3. 泄漏扫描 ──
// 3a. 通用 patterns：任何机器上都不该出现（不含任何真实个人标识）
const genericPatterns = [
  { re: /[A-Za-z]:[\\/]Users[\\/](?!<|%|\$)[A-Za-z0-9._-]+/i, why: 'Windows 本机用户路径' },
  { re: /\/home\/(?!<|\$)[A-Za-z0-9._-]+\//i, why: 'Linux 本机用户路径' },
  { re: /\/Users\/(?!<|\$)[A-Za-z0-9._-]+\//, why: 'macOS 本机用户路径' },
  { re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/, why: '私钥' },
  { re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/, why: 'GitHub token' },
  { re: /\bsk-[A-Za-z0-9_-]{20,}/, why: 'API key (sk-)' },
  { re: /\bAKIA[0-9A-Z]{16}\b/, why: 'AWS access key id' },
  { re: /\bBearer\s+[A-Za-z0-9._~+/=-]{24,}/, why: '硬编码 Bearer 凭据' },
]
// 3b. 维护者私人 deny-list（不入库；缺失即跳过）
const localFile = join(root, 'release-check.local.json')
let localPatterns = []
if (existsSync(localFile)) {
  try {
    const parsed = JSON.parse(readFileSync(localFile, 'utf8'))
    localPatterns = (parsed.patterns || []).filter(Boolean).map((p) => ({
      re: new RegExp(String(p), 'i'),
      why: '本地 deny-list',
    }))
  } catch (e) {
    fail('release-check.local.json 解析失败: ' + String(e.message).slice(0, 200))
  }
  ok(`已加载本地 deny-list（${localPatterns.length} 条，不入库）`)
} else {
  warn('没有 release-check.local.json —— 只跑通用 patterns（维护者本机建议建一份）')
}
const patterns = [...genericPatterns, ...localPatterns]

const SCANNABLE = /\.(mjs|cjs|js|ts|json|md|html|css|yml|yaml|bat|ps1|sh|txt)$/i

// 包清单（= 真正发到包里的文件）
//
// 本仓库用 pnpm 管依赖，而 `npm pack` 在 Node 26 + npm 11 上会报
// Z_DATA_ERROR（zlib incorrect data check）—— 是 npm 侧压缩路径的环境问题，
// 跟包内容无关（同一棵树 `pnpm pack` 好好的）。所以：pnpm 优先，npm 兜底。
//
// 两家的 --json 结构不一样，统一归一化成 { list, size }，后面只认这个形状：
//   pnpm → { name, version, filename, files: [{ path }] }       对象，files 无 size
//   npm  → [ { files: [{ path, size }], size, ... } ]           数组，带 size
function readPackJson() {
  const pnpmCmd = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm'
  const npmCli = join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js')
  const tries = [
    { label: 'pnpm', cmd: pnpmCmd, args: ['pack', '--dry-run', '--json'], shell: process.platform === 'win32' },
    existsSync(npmCli)
      ? { label: 'npm-cli', cmd: process.execPath, args: [npmCli, 'pack', '--dry-run', '--json'], shell: false }
      : { label: 'npm', cmd: npmCmd, args: ['pack', '--dry-run', '--json'], shell: process.platform === 'win32' },
  ]

  const errors = []
  for (const t of tries) {
    try {
      const raw = execFileSync(t.cmd, t.args, { cwd: root, encoding: 'utf8', shell: t.shell })
      // 前面可能混着 pnpm 的进度输出，从第一个 { 或 [ 起截
      const start = [raw.indexOf('{'), raw.indexOf('[')].filter((i) => i >= 0).sort((a, b) => a - b)[0]
      if (start === undefined) throw new Error('输出里没有 JSON')
      const j = JSON.parse(raw.slice(start))
      const entry = Array.isArray(j) ? j[0] : j
      const list = (entry?.files || []).map((f) => f.path).filter(Boolean)
      if (!list.length) throw new Error('清单为空')
      // pnpm 不给 size：逐文件累加（算不出来就 0，只影响日志显示）
      const size = Number(entry?.size) || list.reduce((s, rel) => {
        try { return s + statSync(join(root, rel)).size } catch { return s }
      }, 0)
      return { list, size, via: t.label }
    } catch (e) {
      errors.push(`${t.label}: ${String((e && e.message) || e).slice(0, 160)}`)
    }
  }
  throw new Error(errors.join('；'))
}

let packList = []
let parsedSize = 0
try {
  const pack = readPackJson()
  packList = pack.list
  parsedSize = pack.size
} catch (e) {
  fail(`pack --dry-run 失败（pnpm / npm 都试过）: ${String(e.message || e).slice(0, 300)}`)
}
if (!packList.length) fail('npm pack 清单为空')

// git 跟踪的文档（docs/ 不进 npm 包，但会进公开仓库）
let gitFiles = []
try {
  gitFiles = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8' })
    .split('\n').map((s) => s.trim()).filter(Boolean)
} catch { warn('不是 git 仓库或 git 不可用 —— 只扫 npm 包清单') }

// 只扫我们自己写的文本：npm 包清单里还包含 dsh/pet/dsh-pet-full/node_modules（随包发的第三方依赖），
// 那些文件里的示例用户目录路径是上游作者写的，不是本仓库的泄漏，扫它们只会制造假红。
const isVendored = (rel) => /(^|\/)node_modules\//.test(rel)
const targets = [...new Set([...packList, ...gitFiles])].filter((rel) => SCANNABLE.test(rel) && !isVendored(rel))
let hits = 0
for (const rel of targets) {
  const p = join(root, rel)
  if (!existsSync(p) || statSync(p).isDirectory()) continue
  const content = readFileSync(p, 'utf8')
  for (const { re, why } of patterns) {
    if (re.test(content)) {
      hits++
      console.error(`   ✗ ${rel} ← ${why} (${re})`)
    }
  }
}
if (hits) fail(`泄漏命中 ${hits} 处（个人信息/凭据不得进仓库，见上方清单）`)
ok(`泄漏扫描通过（npm 包 ${packList.length} 个文件 + git 跟踪共扫描 ${targets.length} 个文本文件，0 命中）`)

// ── 4. 包清单可安装性（别人装得上吗）──
// 复用上面已经跑过的 npm pack 清单，不再多打一次包。
const pkgForPack = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
const REQUIRED_IN_PACK = [
  'package.json',
  'dsh/index.mjs',
  'dsh/client.js',
  'dsh/pet-host.mjs',
  'dsh/pet/index.mjs',
  'dsh/pet/hindsight.mjs',
  'dsh/pet/vendor-client.js',
  'dsh/pet/dsh-pet-full/assets/config.jsonc',
  'dsh/dispatch/index.mjs',
  'cordis.patch.yml',
  'dsh/soul-migrate.mjs',
  'dsh/memory-digest.mjs',
  'dsh/memory-dedup.mjs',
  'dsh/pet-emotion-map.mjs',
  'LICENSE',
  'docs/THIRD_PARTY_NOTICES.md',
  'dsh/pet/dsh-pet-full/LICENSE',
]
const FORBIDDEN_IN_PACK = [
  { re: /^node_modules\//, why: '依赖目录不该进包' },
  { re: /^\.git\//, why: '.git 不该进包' },
  { re: /\.tgz$/, why: '旧 tarball 不该进包' },
  { re: /(^|\/)release-check\.local\.json$/, why: '本机 deny-list 绝不进包' },
  { re: /(^|\/)dsh\/client\.raw\.js$/, why: 'esbuild 中间产物不进包' },
  { re: /(^|\/)(\.env|data|backups)\//, why: '运行时数据不该进包' },
  { re: /(^|\/)mcore-soul-(pack-)?[^/]*\.json$/, why: '灵魂迁移包/快照含主人全部记忆，绝不进包' },
  { re: /(^|\/)persona-core\.json/, why: '人格核心运行态含主人全部数据，绝不进包' },
]
const packSet = new Set(packList)
const missing = REQUIRED_IN_PACK.filter((f) => !packSet.has(f))
if (missing.length) fail(`npm 包缺少必需文件（别人装上会残废）: ${missing.join(', ')}`)
for (const f of packList) {
  for (const { re, why } of FORBIDDEN_IN_PACK) {
    if (re.test(f)) fail(`npm 包混进了不该发布的文件: ${f} ← ${why}`)
  }
}
// exports / main 指向的文件必须真实存在（否则 import('mcore') 直接炸）
for (const [key, target] of Object.entries(pkgForPack.exports || {})) {
  const rel = String(target).replace(/^\.\//, '')
  if (!existsSync(join(root, rel))) fail(`exports["${key}"] → ${target} 不存在`)
  if (rel !== 'package.json' && !packSet.has(rel)) fail(`exports["${key}"] → ${rel} 不在 npm 包里`)
}
if (pkgForPack.main) {
  const mainRel = String(pkgForPack.main).replace(/^\.\//, '')
  if (!existsSync(join(root, mainRel))) fail(`main → ${pkgForPack.main} 不存在`)
  if (!packSet.has(mainRel)) fail(`main → ${mainRel} 不在 npm 包里`)
}
// 宠物素材（v0.71.1 起纳入 git）：任何机器 clone 下来都必须能打出完整动画池。
// 少一个就说明素材没进仓库 → 别人装上去「有气泡、没画面」，这里直接拦死。
// 2026-11-03：dsh-pet 整包搬进 dsh/pet/dsh-pet-full/，素材跟着过去；旧位置兜底。
const webmDir = ['dsh/pet/dsh-pet-full/assets/webm', 'dsh/pet/assets/webm']
  .map((p) => join(root, p))
  .find((p) => existsSync(p) && readdirSync(p).some((f) => /\.webm$/i.test(f)))
const webmCount = webmDir ? readdirSync(webmDir).filter((f) => /\.webm$/i.test(f)).length : 0
const ASSET_WEBM_MIN = 100
if (webmCount < ASSET_WEBM_MIN) {
  fail(`宠物素材不全：webm 只有 ${webmCount} 个动画（应 ≥ ${ASSET_WEBM_MIN}，完整应为 106）。` +
    ' 查过 dsh/pet/dsh-pet-full/assets/webm 与 dsh/pet/assets/webm 两处。' +
    ' 素材必须跟着 git 走，否则干净 clone 打出来的包只剩气泡、没有画面。')
}
// 运行时依赖必须真的声明（漏一个，干净环境就 ERR_MODULE_NOT_FOUND）
const runtimeDeps = Object.keys(pkgForPack.dependencies || {})
ok(`包清单通过（${packList.length} 个文件 / ${(parsedSize / 1024 / 1024).toFixed(1)} MB，素材 ${webmCount} 个动画，exports ${Object.keys(pkgForPack.exports || {}).length} 个键全在包内，运行时依赖 ${runtimeDeps.length ? runtimeDeps.join(',') : '无'}）`)

// ── 5. client 产物门禁（防「源码改了没重建 / 有人手改产物」）──
// 历史上 dsh/client.js / client.raw.js / client-dhc.mjs 三份各改各的：源码改了、esbuild 起不来，
// 就手改产物 —— 结果是「源码说是 A、线上跑的是 B」，而且没人能看出来。
// 这里用 build-client 同一份 wrapClient() 重算一遍，逐字节比对。
{
  const rawPath = join(root, 'dsh/client.raw.js')
  const outPath = join(root, 'dsh/client.js')
  if (!existsSync(outPath)) fail('缺 dsh/client.js（客户端整块不会加载）')
  if (!existsSync(rawPath)) fail('缺 dsh/client.raw.js（无法校验产物来源）')
  const fp = sourceFingerprint((rel) => readFileSync(join(root, rel), 'utf8'))
  const expected = wrapClient(readFileSync(rawPath, 'utf8'), pkgForPack.name, { sourceFingerprint: fp })
  const actual = readFileSync(outPath, 'utf8')
  const onDiskFp = (actual.match(/^\/\/ mcore-client-src: ([0-9a-f]+)$/m) || [])[1] || ''
  if (!onDiskFp) {
    fail('dsh/client.js 没有源码指纹行（// mcore-client-src: …）—— 跑 `node build-client.mjs --no-build` 重建')
  }
  if (onDiskFp !== fp) {
    fail(`client 产物已过期：产物指纹 ${onDiskFp} ≠ 当前源码 ${fp}（client-entry/client-dhc/client-wrap 改过但没重建）。` +
      ' 跑 `npm run build:client`（没 esbuild 时先 `node build-client.mjs --no-build` 只重包装）')
  }
  if (expected !== actual) {
    let i = 0
    while (i < Math.min(expected.length, actual.length) && expected[i] === actual[i]) i++
    fail(`dsh/client.js 与 client.raw.js 不一致（首个差异 @${i}）—— 别手改产物，跑 npm run build:client 重建`)
  }
  if (!actual.includes('window.__mcoreRequire = require')) fail('dsh/client.js 缺 window.__mcoreRequire 注入（宠物渲染器物化会失败）')
  ok(`client 产物一致（${Buffer.byteLength(actual)} bytes，源码指纹 ${fp}）`)
}

// ── 6. 版本一致性 ──
const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
const indexSrc = readFileSync(join(root, 'dsh/index.mjs'), 'utf8')
const m = indexSrc.match(/PLUGIN_VERSION = '([^']+)'/)
if (!m) fail('index.mjs 未找到 PLUGIN_VERSION')
if (m[1] !== pkg.version) fail(`版本不一致: package.json=${pkg.version} vs index.mjs=${m[1]}`)
let tag = ''
try {
  tag = execFileSync('git', ['describe', '--tags', '--abbrev=0'], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
} catch { /* 无 tag / 非 git 仓库 */ }
if (tag && tag.replace(/^v/, '') !== pkg.version) {
  const msg = `版本不一致: package.json=${pkg.version} vs 最新 tag=${tag}（发版后 push tag 即过）`
  if (allowUntagged) warn(msg + ' —— --allow-untagged 放行')
  else fail(msg)
}
ok(`版本一致性通过（package.json=${pkg.version} = index.mjs=${m[1]}${tag ? ' = ' + tag : ''}）`)

// ── 7. 开源隔离（隐私只走夺舍/恢复通道，不许进仓库、不许进包）──
{
  // 7a. 人格模板必须是空壳：本地跑过之后误提交是最现实的泄漏路径
  const tplPath = join(root, 'persona-core.template.json')
  if (existsSync(tplPath)) {
    let tpl = null
    try { tpl = JSON.parse(readFileSync(tplPath, 'utf8')) } catch { fail('persona-core.template.json 不是合法 JSON') }
    if (tpl) {
      const bad = []
      if (typeof tpl.name === 'string' && tpl.name.trim()) bad.push('name=' + String(tpl.name).slice(0, 20))
      if (tpl.heart && typeof tpl.heart.machineId === 'string' && tpl.heart.machineId.trim()) bad.push('heart.machineId 非空')
      for (const k of ['notes', 'archive', 'skills', 'kb', 'milestones', 'eventLog']) {
        if (Array.isArray(tpl[k]) && tpl[k].length) bad.push(k + '=' + tpl[k].length + ' 条')
      }
      if (tpl.memory) {
        for (const k of ['notes', 'archive']) {
          if (Array.isArray(tpl.memory[k]) && tpl.memory[k].length) bad.push('memory.' + k + '=' + tpl.memory[k].length + ' 条')
        }
        if (typeof tpl.memory.profile === 'string' && tpl.memory.profile.trim()) bad.push('memory.profile 非空')
      }
      if (bad.length) fail('persona-core.template.json 不是空壳（' + bad.join(' / ') + '）—— 真实人格数据只许走夺舍导出/恢复导入，不能留在仓库里')
      ok('人格模板为空壳（无 name / 无 machineId / 无记忆与画像）')
    }
  }

  // 7b. 源码不许硬编码机器码（运行时读取是唯一合法来源）
  const UUID_RE = /machineId\s*[:=]\s*['"][0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}['"]/
  const hard = []
  for (const f of readdirSync(join(root, 'dsh')).filter((x) => x.endsWith('.mjs'))) {
    if (UUID_RE.test(readFileSync(join(root, 'dsh', f), 'utf8'))) hard.push(f)
  }
  if (hard.length) fail('源码硬编码机器码: ' + hard.join(', ') + ' —— 必须运行时读取')
  ok('源码无硬编码机器码')

  // 7c. 迁移包格式字面量只许出现在 soul-migrate 系列（防止导出逻辑散到别处）
  const SCHEMA_LIT = "'dhc-soul-migrate'"
  const schemaFiles = readdirSync(join(root, 'dsh'))
    .filter((x) => x.endsWith('.mjs') && x !== 'soul-migrate.mjs' && x.indexOf('soul-migrate.test') === -1)
    .filter((x) => readFileSync(join(root, 'dsh', x), 'utf8').indexOf(SCHEMA_LIT) !== -1)
  if (schemaFiles.length) fail('迁移包 schema 字面量出现在 ' + schemaFiles.join(', ') + ' —— 夺舍/恢复逻辑必须收在 soul-migrate.mjs')
  ok('迁移包格式只在 soul-migrate 系列内')
}
console.log('🎉 release-check 全部通过，可以 publish / 打 tag')