@lqc123qwe/car-runtime 1.9.0 → 1.11.0

package/scripts/release-pipeline.ts

@@ -1,245 +0,0 @@
-/**
- * 发布工程预演（本地 dry-run 版 8 阶段流水线，对齐《部署设计》§4/§6）
- *
- * 真实执行：门禁 13 项中本地可跑的 9 项（测试/不变量/密钥扫描/版本一致性/SBOM/校验和/
- *           逃逸矩阵定义校验/依赖零原生审计/dist-tag 晋级模拟+回滚演练）
- * DRY-RUN：npm publish（OIDC provenance）/ cosign keyless 签名 / GitHub Releases 归档
- *          ——需远端凭据与仓库，预演报告标注 DRY-RUN 与正式执行前置条件
- *
- * 运行：node --experimental-transform-types scripts/release-pipeline.ts
- */
-import { execSync, execFileSync } from 'node:child_process'
-import { createHash } from 'node:crypto'
-import { readFileSync, writeFileSync, readdirSync, statSync, mkdirSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { buildReleaseArtifacts, releaseAssetNames } from './release-artifacts.ts'
-
-const ROOT = new URL('..', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1')
-const DIST = join(ROOT, 'dist')
-const VERSION = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version as string
-const audit: any[] = []
-const auditLog = (stage: string, gate: string, verdict: string, detail: Record<string, unknown> = {}) =>
-  audit.push({ stage, gate, verdict, ts: Date.now(), ...detail })
-const sha256 = (s: string | Buffer) => createHash('sha256').update(s).digest('hex')
-
-function walk(dir: string, ext: string): string[] {
-  const out: string[] = []
-  for (const name of readdirSync(dir)) {
-    const p = join(dir, name)
-    if (statSync(p).isDirectory()) out.push(...walk(p, ext))
-    else if (p.endsWith(ext)) out.push(p)
-  }
-  return out
-}
-
-const results: Array<{ stage: string; gate: string; verdict: string; detail?: string }> = []
-const record = (stage: string, gate: string, ok: boolean, detail = '', dryRun = false) => {
-  const verdict = dryRun ? 'DRY-RUN' : ok ? 'PASS' : 'FAIL'
-  results.push({ stage, gate, verdict, detail })
-  auditLog(stage, gate, verdict, { detail })
-  if (!dryRun && !ok) throw new Error(`GATE FAILED: ${stage}/${gate} ${detail}`)
-}
-
-// ── 阶段 1：PR 门禁（int）──
-{
-  const stage = 'S1-PR 门禁'
-  // reporter 钉死 tap：非 TTY 默认 reporter 随 Node 版本漂移（23.x 输出 spec 格式，正则解析不到 # pass/# fail）
-  const out = execSync('node --experimental-transform-types --test --test-reporter=tap test/*.spec.ts', { cwd: ROOT, encoding: 'utf-8' })
-  const pass = /# pass (\d+)/.exec(out)?.[1]
-  const fail = /# fail (\d+)/.exec(out)?.[1]
-  record(stage, 'G-01 单测全绿', fail === '0', `${pass} pass / ${fail} fail`)
-  record(stage, 'G-02 N1 日志不变量断言', out.includes('48/48') || fail === '0', 'assertModelVisibleLogged 内嵌于测试套件')
-  // 密钥扫描（gitleaks 等价简化规则集：真实 CI 用 gitleaks 全量规则）
-  // 豁免清单与 scripts/secrets-scan.ts（CI 权威版）保持同步：规则库 + E-5 万级基准集生成器
-  // （内含仿真密钥模板，命中属预期）+ 对应标定 spec；豁免须显式列文件路径（M2-S10 口径）。
-  // 同步失守教训：E-5 入库时只扩了 CI 清单，本地 G-03 漏扩 → 复跑误 FAIL（2026-09-26 已对齐）
-  const secretPatterns = [/sk-[A-Za-z0-9]{16,}/, /ghp_[A-Za-z0-9]{20,}/, /BEGIN (RSA |EC )?PRIVATE KEY/, /AKIA[A-Z0-9]{12,}/]
-  const scanExempt = (f: string) => {
-    const n = f.replaceAll('\\', '/')
-    return /\/src\/security\/secrets(\.ts|-baseline\.ts)$/.test(n)
-      || /\/test\/s7(b-baseline)?\.spec\.ts$/.test(n)
-      || /\/scripts\/secrets-baseline\.ts$/.test(n)
-  }
-  let hits = 0
-  let scanned = 0
-  for (const f of [...walk(join(ROOT, 'src'), '.ts'), ...walk(join(ROOT, 'test'), '.ts')]) {
-    if (scanExempt(f)) continue
-    scanned++
-    const content = readFileSync(f, 'utf-8')
-    for (const p of secretPatterns) if (p.test(content)) hits++
-  }
-  record(stage, 'G-03 硬编码密钥扫描 = 0', hits === 0, `${hits} hits（扫描 ${scanned} 个 .ts，豁免：secrets.ts 规则库 + s7 标定基准，豁免清单见脚本注记）`)
-  // 依赖审计：1.5-S3（D-22）zod 为首个常规运行时依赖 → 门禁口径从「零依赖断言」切换为
-  // npm audit（omit=dev，high 阻塞）——与 ci.yml j01 依赖审计同款；audit 不可达（离线）= DRY-RUN
-  const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8'))
-  const depCount = Object.keys(pkg.dependencies ?? {}).length
-  let auditOk = true
-  let auditDetail = '无运行时依赖（audit 免除）'
-  if (depCount > 0) {
-    if (process.env.REMOTE_CHECK === '1') {
-      try {
-        execSync('npm audit --omit=dev --audit-level=high', { cwd: ROOT, stdio: 'pipe' })
-        auditDetail = `运行时依赖 ${depCount} 项（D-22/D-24：zod ^3 + jiti ^2）；npm audit --omit=dev --audit-level=high 0 findings`
-      } catch {
-        auditOk = false
-        auditDetail = `运行时依赖 ${depCount} 项；npm audit --audit-level=high 有 findings（阻塞——G-04 D-22 口径）`
-      }
-    } else {
-      auditDetail = `运行时依赖 ${depCount} 项（D-22/D-24：zod ^3 + jiti ^2）；npm audit 在 REMOTE_CHECK=1 实跑（DRY-RUN）`
-    }
-  }
-  record(stage, 'G-04 依赖审计', auditOk, auditDetail)
-}
-
-// ── 阶段 2：构建与制品 ──
-{
-  const stage = 'S2-构建与制品'
-  // 1.3-S2（W4-1）：制品构建抽至 release-artifacts.ts（本地流水线与 CI j16 双端单一事实源——
-  // 同仓树逐字节同制品）；此处产出 tgz + SHA256SUMS + sbom，G-11 在 S6 独立复核
-  const built = buildReleaseArtifacts({
-    version: VERSION,
-    onRecord: (s, detail) => auditLog(stage, s.toUpperCase(), 'PASS', { detail }),
-  })
-  record(stage, 'G-05 SBOM 生成', true, `${built.components} 个组件（运行时依赖 0 项；tar.gz ${built.bytes} bytes 已构建——W4 单一事实源）`)
-  // 版本一致性：精确 semver（含 prerelease——1.0-rc.x 是 rc 渠道合法形态；禁止 build 元数据与 loose 版本）
-  const ok = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(VERSION) && !/\+/.test(VERSION)
-  record(stage, 'G-06 版本一致性', ok, `version=${VERSION}（精确 semver 含 prerelease——rc 渠道合法形态；npm 不可变语义：禁止覆盖已发布版本）`)
-}
-
-// ── 阶段 3：沙箱逃逸回归（Linux 门禁，WSL2 实跑后凭审计产物转 PASS）──
-{
-  const stage = 'S3-沙箱逃逸回归'
-  const matrixFile = join(ROOT, '..', 'deepseek-harness', 'm0-poc', 'poc4-sandbox-escape.ts')
-  // Linux 实跑审计产物（WSL2 内跑完后回拷，20 行逐用例 verdict=PASS）
-  const auditLinux = join(ROOT, '..', 'deepseek-harness', 'm0-poc', 'poc4-audit-linux.jsonl')
-  let linuxPass = false
-  let linuxDetail = '20 条用例 × 5 类（v0 冻结）；尚未在 Linux/WSL2 实跑——AL-04 P1：任一逃逸阻塞发布'
-  let linuxDryRun = process.platform !== 'linux'
-  if (existsSync(auditLinux)) {
-    const cases = readFileSync(auditLinux, 'utf-8').trim().split('\n').filter(Boolean).map(l => JSON.parse(l))
-    const passN = cases.filter(c => c.verdict === 'PASS').length
-    linuxPass = cases.length === 20 && passN === 20
-    linuxDryRun = false
-    linuxDetail = linuxPass
-      ? `20/20 PASS（backend=${cases[0]?.backend ?? '?'}）→ AL-04 满足`
-      : `审计产物不完整/含非 PASS：${cases.length} 行，${passN} PASS——AL-04 P1 任一逃逸即阻塞`
-  } else if (!existsSync(matrixFile)) {
-    linuxPass = false
-    linuxDryRun = false
-    linuxDetail = '逃逸矩阵用例定义文件缺失'
-  }
-  record(stage, 'G-07 逃逸矩阵实跑', linuxPass, linuxDetail, linuxDryRun)
-}
-
-// ── 阶段 4-5：provenance 与远端归档（远端依赖，DRY-RUN）──
-// G-08 双轨语义（1.3 D-15）：本地 keypair no-tlog = 预演态（S6b）；CI j16 keyless OIDC+Rekor = 正式态
-// G-10：REMOTE_CHECK=1 且具备 GH_TOKEN 时实查 Release 资产齐备性，否则 DRY-RUN
-{
-  const stage = 'S4-provenance与远端归档'
-  let g10Ok = false
-  let g10Detail = '需远端仓库（远端）'
-  let g10Dry = true
-  if (process.env.GH_TOKEN && process.env.REMOTE_CHECK === '1') {
-    try {
-      const ghBin = 'D:/WorkBuddy/agent/tools/bin/gh.exe'
-      // tag 形态双兼容：v 前缀（v1.0.0 惯例）与无前缀（1.1.0 实挂形态）都查，并集去重——
-      // 硬编码单形态会把真实归档误判 FAIL（4c84b17 G-09 期望 tag 动态化同类教训，2026-09-27）
-      const fetchAssets = (tag: string): string[] => {
-        try {
-          return execFileSync(ghBin, ['api', `repos/lqc624/car-runtime/releases/tags/${tag}`, '--jq', '.assets[].name'], { encoding: 'utf-8', env: process.env }).trim().split('\n').filter(Boolean)
-        } catch { return [] }
-      }
-      const assets = [...new Set([...fetchAssets(`v${VERSION}`), ...fetchAssets(VERSION)])]
-      // 资产清单单一事实源（1.3 W4-4/R-3）：releaseAssetNames（五件套，无 car-release.pub）
-      const need = releaseAssetNames(VERSION)
-      const missing = need.filter(n => !assets.includes(n))
-      g10Ok = missing.length === 0
-      g10Dry = false
-      g10Detail = g10Ok
-        ? `Release v${VERSION} 归档齐备（${assets.length} assets：tgz+签名bundle+SHA256SUMS+SBOM+审计——D-14 五件套）`
-        : `Release 资产缺失：${missing.join(', ')}`
-    } catch { /* 远端不可达或 Release 不存在 → 保持 DRY-RUN */ }
-  }
-  record(stage, 'G-10 GitHub Releases 归档（napi 二进制+SBOM+校验和）', g10Ok, g10Detail, g10Dry)
-  // G-09：REMOTE_CHECK=1 时实查 npm registry——版本在架 + 期望 dist-tag + provenance 证明。
-  // 期望 tag 按版本形态动态选择（与 release.yml publish tag 同口径，M5 §1.1）：
-  // prerelease（1.0.0-rc.1）→ rc；稳定版（1.0.0）→ latest——1.0 发布后 rc tag 保留指向 rc.1，
-  // 硬编码查 rc 会把 1.0.0 的 post-publish 复跑误判 FAIL（09-26 与 release.yml 同批修口径）
-  const expectedTag = VERSION.includes('-') ? 'rc' : 'latest'
-  let g9Ok = false
-  let g9Detail = '需 npm publish 通道（远端）'
-  let g9Dry = true
-  if (process.env.REMOTE_CHECK === '1') {
-    try {
-      const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm'
-      const view = execFileSync(npmBin, ['view', '@lqc123qwe/car-runtime', 'version', `dist-tags.${expectedTag}`, 'dist.attestations.provenance.predicateType', '--json'], { encoding: 'utf-8', shell: process.platform === 'win32' })
-      const j = JSON.parse(view)
-      const onRegistry = j.version === VERSION
-      const tagOk = j[`dist-tags.${expectedTag}`] === VERSION
-      const provenance = typeof j['dist.attestations.provenance.predicateType'] === 'string' && j['dist.attestations.provenance.predicateType'].includes('slsa.dev/provenance')
-      g9Ok = onRegistry && tagOk && provenance
-      g9Dry = false
-      g9Detail = g9Ok
-        ? `npm 在架 @lqc123qwe/car-runtime@${VERSION}（${expectedTag} tag ✓ + SLSA provenance ✓，Actions OIDC 可信发布）`
-        : `registry 不满足：version=${j.version} ${expectedTag}=${j[`dist-tags.${expectedTag}`]} provenance=${j['dist.attestations.provenance.predicateType'] ?? '无'}`
-    } catch { /* registry 不可达或包未发布 → 保持 DRY-RUN */ }
-  }
-  record(stage, 'G-09 npm provenance（OIDC 可信发布）', g9Ok, g9Detail, g9Dry)
-}
-
-// ── 阶段 6：制品校验（G-11：对 S2 产出的制品做独立复核，不重建不写死） ──
-const TARBALL = join(DIST, `car-runtime-${VERSION}.tgz`)
-{
-  const stage = 'S6-制品封装'
-  // 校验和必须对「裸字节」求哈希——曾误写为 sha256(bytes.toString('base64'))，
-  // 记录值成为 base64 字符串的哈希，外部 sha256sum 校验必然失败（rc.1 已发生）。
-  const bytes = readFileSync(TARBALL)
-  const actual = sha256(bytes)
-  const [recorded, recordedName] = readFileSync(join(DIST, 'SHA256SUMS'), 'utf-8').trim().split(/\s+/)
-  const ok = recorded === actual && recordedName === `car-runtime-${VERSION}.tgz`
-  record(stage, 'G-11 制品校验和（SHA-256）', ok, ok
-    ? `car-runtime-${VERSION}.tgz (${bytes.length} bytes) → SHA256SUMS ${recorded!.slice(0, 16)}…（S2 产出独立复核，外部 sha256sum 可验证）`
-    : `校验和自检失败：SHA256SUMS 记录 ${recorded} ≠ 制品裸字节哈希 ${actual}`)
-}
-
-// ── 阶段 6b：cosign 本地实签 + 验签（G-08，keypair 模式；CI 正式发布切换 keyless OIDC）──
-{
-  const stage = 'S6b-cosign签名'
-  const cosignBin = process.env.COSIGN_BIN ?? 'D:/WorkBuddy/agent/tools/bin/cosign.exe'
-  const keysDir = 'D:/WorkBuddy/agent/tools/cosign-keys'
-  const sigConfig = join(keysDir, 'no-tlog.json')
-  const bundle = join(DIST, `car-runtime-${VERSION}.tgz.sig.bundle`)
-  const env = { ...process.env, COSIGN_PASSWORD: readFileSync(join(keysDir, 'car-release.password'), 'utf-8').trim() }
-  execFileSync(cosignBin, ['sign-blob', '--key', join(keysDir, 'car-release.key'),
-    '--signing-config', sigConfig, '--bundle', bundle, TARBALL], { env })
-  execFileSync(cosignBin, ['verify-blob', '--key', join(keysDir, 'car-release.pub'),
-    '--insecure-ignore-tlog', '--bundle', bundle, TARBALL], { env })
-  record(stage, 'G-08 cosign 签名', existsSync(bundle), `本地 keypair 实签+验签 PASS（no-tlog 模式，bundle: car-runtime-${VERSION}.tgz.sig.bundle）——D-15 预演轨；正式轨 = CI j16 keyless OIDC+Rekor`)
-}
-
-// ── 阶段 7：dist-tag 晋级模拟 + 回滚演练（发布渠道语义）──
-{
-  const stage = 'S7-dist-tag 晋级模拟'
-  // 本地模拟 npm 三渠道：beta → rc → latest（等价金丝雀）
-  const registry = existsSync(join(DIST, 'registry-sim.json'))
-    ? JSON.parse(readFileSync(join(DIST, 'registry-sim.json'), 'utf-8'))
-    : { 'beta': null, 'rc': null, 'latest': null, immutable: [] }
-  registry['beta'] = VERSION
-  writeFileSync(join(DIST, 'registry-sim.json'), JSON.stringify(registry, null, 2))
-  record(stage, 'G-12 渠道晋级：beta → rc → latest', registry['beta'] === VERSION, JSON.stringify(registry))
-  // 回滚演练：latest 回指旧版本 + 前滚补丁纪律（npm 版本不可变 → 回滚=dist-tag 回指）
-  registry['latest'] = registry['rc'] ?? registry['beta']
-  writeFileSync(join(DIST, 'registry-sim.json'), JSON.stringify(registry, null, 2))
-  record(stage, 'G-13 回滚演练：latest 回指 + 前滚补丁', true, 'npm 版本不可变（禁止覆盖已发布版本）；回滚=dist-tag 回指，破坏性变更走 major+reader 兼容（SessionEventMap 只增不删）')
-}
-
-// ── 阶段 8：审计留痕 ──
-writeFileSync(join(DIST, 'release-audit.jsonl'), audit.map(a => JSON.stringify(a)).join('\n') + '\n')
-
-// ── 汇总 ──
-console.log('\n===== 发布工程预演结果 =====')
-for (const r of results) console.log(`  [${r.verdict.padEnd(7)}] ${r.stage} / ${r.gate}${r.detail ? ' — ' + r.detail : ''}`)
-const pass = results.filter(r => r.verdict === 'PASS').length
-const dry = results.filter(r => r.verdict === 'DRY-RUN').length
-console.log(`\n合计：${pass} PASS / ${dry} DRY-RUN / 0 FAIL（制品：dist/ 五件套——tar.gz + 签名bundle + SHA256SUMS + sbom + release-audit）`)
-console.log('DRY-RUN 项正式执行前置：GitHub 仓库 + OIDC + npm publish 凭据 + cosign + Linux CI runner（逃逸矩阵 G-07）；正式签名轨 = CI j16 keyless（D-15）')

package/scripts/secrets-baseline.ts

@@ -1,33 +0,0 @@
-/**
- * E-5 secrets 基准集 CLI（M2 退出标准 #4 终验入口）
- *
- * 用法：node --experimental-transform-types scripts/secrets-baseline.ts
- * 产出：dist/ci/secrets-baseline.json（计数与聚合指标，无样本原文）
- * 退出码：判据全过 = 0；任一判据不满足 = 1（漏报 ≥1.5% / FPR >5% / precision <80%）
- */
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { runBaseline } from '../src/security/secrets-baseline.ts'
-
-const result = runBaseline(1000, 9000)
-const report = {
-  generatedAt: new Date().toISOString(),
-  seedPos: 20260918,
-  seedNeg: 20260919,
-  ...result,
-}
-mkdirSync('dist/ci', { recursive: true })
-writeFileSync('dist/ci/secrets-baseline.json', JSON.stringify(report, null, 2))
-
-console.log('E-5 secrets baseline (1:9, 1000 pos + 9000 neg):')
-console.log(`  TP=${result.tp} FN=${result.fn} FP=${result.fp} TN=${result.tn}`)
-console.log(`  missRate=${(result.missRate * 100).toFixed(2)}% (criterion <1.5%)`)
-console.log(`  FPR=${(result.fpr * 100).toFixed(2)}% (criterion <=5%)`)
-console.log(`  precision=${(result.precision * 100).toFixed(2)}% (criterion >=80%)`)
-console.log(`  report: dist/ci/secrets-baseline.json`)
-if (!result.pass) {
-  console.log(`  missByClass=${JSON.stringify(result.missByClass)}`)
-  console.log(`  fpByClass=${JSON.stringify(result.fpByClass)}`)
-  console.error('E-5 CRITERIA VIOLATED')
-  process.exit(1)
-}
-console.log('  PASS')

package/scripts/secrets-scan.ts

@@ -1,56 +0,0 @@
-/**
- * J-01 lint-scan-build · 仓库密钥扫描门禁（M2部署设计增补 §2.3 / ci.yml 幽灵注释兑现项）
- *
- * 口径：扫 git 跟踪文件（git ls-files），命中即 exit 1——补 CI 供应链第二道门（s7.spec 的
- * 规则库是样本级断言，本脚本是仓库级常驻扫描；两者共用同一模式集口径）。
- * 规则集（高置信，宁缺勿滥——低置信规则走人工评审，不进 fail-closed 门禁）：
- *   GitHub PAT / npm token / AWS AKIA / PEM 私钥块 / 通用密钥赋值 / ≥60 位连续 base64
- * 豁免：环境变量名引用（process.env.X / ${X}）不算命中；文本行内示例占位不算命中。
- */
-import { execFileSync } from 'node:child_process'
-import { readFileSync } from 'node:fs'
-
-const RULES: Array<[string, RegExp]> = [
-  ['github-pat', /gh[pousr]_[A-Za-z0-9]{20,}/],
-  ['npm-token', /npm_[A-Za-z0-9]{30,}/],
-  ['aws-access-key', /AKIA[0-9A-Z]{16}/],
-  ['pem-private-key', /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
-  ['generic-secret-assign', /(?:password|passwd|secret|api[_-]?key|access[_-]?token)\s*[:=]\s*['"][^'"]{12,}['"]/i],
-  ['long-base64-blob', /[A-Za-z0-9+/]{80,}={0,2}/],
-]
-
-const tracked = execFileSync('git', ['ls-files'], { encoding: 'utf8' })
-  .split(/\r?\n/).filter(Boolean)
-
-let findings = 0
-for (const file of tracked) {
-  let content: string
-  try { content = readFileSync(file, 'utf8') } catch { continue /* 二进制/不可读：跳过（sha 类二进制物无密钥文本面） */ }
-  if (content.includes('\u0000')) continue // 二进制
-  content.split('\n').forEach((line, i) => {
-    for (const [name, re] of RULES) {
-      if (!re.test(line)) continue
-      // 豁免 1：环境变量引用（运行时注入，非硬编码）
-      if (name === 'generic-secret-assign' && /process\.env\.|\$\{[A-Z_]+\}/.test(line)) continue
-      // 豁免 2：锁文件 integrity 字段（sha512- 前缀的依赖指纹，非密钥）
-      if (name === 'long-base64-blob' && /"integrity":\s*"sha512-/.test(line)) continue
-      // 豁免 3：规则/样本/基准集定义文件自身（模式定义与基准集生成处必然"命中"）
-      //   - secrets.ts = 规则库；secrets-baseline.ts/s7b.spec.ts = E-5 万级基准集生成器（内含仿真密钥模板）
-      if (
-        file.endsWith('secrets-scan.ts') ||
-        /^src\/security\/secrets(\.ts|-baseline\.ts)$/.test(file) ||
-        /^test\/s7(b-baseline)?\.spec\.ts$/.test(file) ||
-        file === 'scripts/secrets-baseline.ts'
-      ) continue
-      console.error(`  [${name}] ${file}:${i + 1}  ${line.trim().slice(0, 90)}`)
-      findings++
-    }
-  })
-}
-
-const summary = JSON.stringify({ gate: 'J-01-secrets-scan', files: tracked.length, findings, ok: findings === 0, ts: Date.now() })
-if (findings > 0) {
-  console.error(`FAIL ${summary}`)
-  process.exit(1)
-}
-console.log(`PASS ${summary}`)

package/scripts/win32-ffi-debug.ts

@@ -1,143 +0,0 @@
-/**
- * win32 FFI 诊断矩阵（M5-S26 临时诊断，非门禁）：定位 windows-2025 runner 上
- * CreateProcessAsUserW 子进程 0xC0000142（STATUS_DLL_INIT_FAILED）的确切触发条件。
- * 矩阵：API（AsUser/WithToken/normal）× 环境块（NULL/显式 Unicode）×
- *       标志（CREATE_NO_WINDOW/DETACHED_PROCESS）× 程序（cmd/whoami/node）× token（原发/受限）。
- * 本机（非提权交互会话）全绿为基线；runner 上首个失败行即回归点。
- */
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-
-const koffi = (await import('koffi')).default ?? (await import('koffi') as any)
-const kernel32 = koffi.load('kernel32.dll')
-const advapi32 = koffi.load('advapi32.dll')
-
-const CREATE_NO_WINDOW = 0x08000000
-const CREATE_SUSPENDED = 0x00000004
-const CREATE_UNICODE_ENVIRONMENT = 0x00000400
-const DETACHED_PROCESS = 0x00000008
-const STILL_ACTIVE = 259
-const PSEUDO_CURRENT_PROCESS = BigInt.asUintN(64, -1n)
-const SystemRoot = process.env.SystemRoot ?? 'C:\\Windows'
-
-const SID_AND_ATTRIBUTES = koffi.struct('SID_AND_ATTRIBUTES', { Sid: 'void *', Attributes: 'uint32' })
-const CloseHandle = kernel32.func('int32 __stdcall CloseHandle(uint64 hObject)')
-const WaitForSingleObject = kernel32.func('uint32 __stdcall WaitForSingleObject(uint64 hHandle, uint32 dwMilliseconds)')
-const ResumeThread = kernel32.func('uint32 __stdcall ResumeThread(uint64 hThread)')
-const GetExitCodeProcess = kernel32.func('int32 __stdcall GetExitCodeProcess(uint64 hProcess, void *lpExitCode)')
-const OpenProcessToken = advapi32.func('int32 __stdcall OpenProcessToken(uint64 ProcessHandle, uint32 DesiredAccess, void *TokenHandle)')
-const CreateRestrictedToken = advapi32.func('int32 __stdcall CreateRestrictedToken(uint64 ExistingTokenHandle, uint32 Flags, uint32 DisableSidCount, SID_AND_ATTRIBUTES *SidsToDisable, uint32 DeletePrivilegeCount, void *PrivilegesToDelete, uint32 RestrictedSidCount, void *SidsToRestrict, void *NewTokenHandle)')
-const CreateProcessAsUserW = advapi32.func('int32 __stdcall CreateProcessAsUserW(uint64 hToken, void *lpApplicationName, void *lpCommandLine, void *pa, void *ta, int32 bInherit, uint32 flags, void *env, void *dir, void *si, void *pi)')
-const CreateProcessW = kernel32.func('int32 __stdcall CreateProcessW(void *lpApplicationName, void *lpCommandLine, void *pa, void *ta, int32 bInherit, uint32 flags, void *env, void *dir, void *si, void *pi)')
-const CreateProcessWithTokenW = advapi32.func('int32 __stdcall CreateProcessWithTokenW(uint64 hToken, uint32 logonFlags, void *lpApplicationName, void *lpCommandLine, uint32 flags, void *env, void *dir, void *si, void *pi)')
-
-function buildEnvBlock(): Buffer {
-  const env: Record<string, string> = {}
-  for (const [k, v] of Object.entries(process.env)) if (v !== undefined) env[k] = v
-  if (env.SystemRoot === undefined) env.SystemRoot = SystemRoot
-  if (env.windir === undefined) env.windir = SystemRoot
-  if (env.SystemDrive === undefined) env.SystemDrive = 'C:'
-  return Buffer.from(Object.entries(env).map(([k, v]) => `${k}=${v}`).join('\0') + '\0\0', 'utf16le')
-}
-
-function buildAdminSid(): Buffer {
-  const b = Buffer.alloc(16)
-  b[0] = 1; b[1] = 2; b.set([0, 0, 0, 0, 0, 5], 2)
-  b.writeUInt32LE(32, 8); b.writeUInt32LE(544, 12)
-  return b
-}
-
-function hexExit(code: number): string {
-  return code === STILL_ACTIVE ? 'STILL_ACTIVE' : (code >= 0x80000000 ? `0x${code.toString(16).toUpperCase()}` : String(code))
-}
-
-interface Variant {
-  label: string
-  api: 'normal' | 'asUser' | 'withToken'
-  token: 'plain' | 'restricted'
-  env: 'null' | 'block'
-  flags: number
-  program: 'cmd' | 'whoami' | 'node'
-  explicitAppName?: boolean
-}
-
-const results: string[] = []
-async function runVariant(v: Variant, hToken: bigint, hRestricted: bigint, execPath: string): Promise<void> {
-  const dir = mkdtempSync(path.join(tmpdir(), 'car-dbg-'))
-  const outFile = path.join(dir, 'out.txt')
-  const program = v.program === 'cmd' ? path.join(SystemRoot, 'System32', 'cmd.exe')
-    : v.program === 'whoami' ? path.join(SystemRoot, 'System32', 'whoami.exe')
-    : execPath
-  const cmdline = v.program === 'cmd'
-    ? `"${program}" /c exit 0`
-    : v.program === 'whoami'
-      ? `"${program}" /priv /fo list`
-      : `"${program}" -e process.exit(0)`
-  const cmdBuf = Buffer.from(cmdline + '\0', 'utf16le')
-  const si = Buffer.alloc(104); si.writeUInt32LE(104, 0)
-  const pi = Buffer.alloc(24)
-  const envArg = v.env === 'block' ? buildEnvBlock() : null
-  const flags = v.env === 'block' ? (v.flags | CREATE_UNICODE_ENVIRONMENT) : v.flags
-  const tok = v.token === 'restricted' ? hRestricted : hToken
-  let ok = 0
-  try {
-    if (v.api === 'normal') {
-      ok = CreateProcessW(null, cmdBuf, null, null, 0, flags, envArg, null, si, pi)
-    } else if (v.api === 'asUser') {
-      ok = CreateProcessAsUserW(tok, null, cmdBuf, null, null, 0, flags, envArg, null, si, pi)
-    } else {
-      ok = CreateProcessWithTokenW(tok, 0, null, cmdBuf, flags, envArg, null, si, pi)
-    }
-    if (!ok) {
-      results.push(`${v.label}: CREATE_FAILED rc=0`)
-      return
-    }
-    const hProcess = pi.readBigUInt64LE(0)
-    const hThread = pi.readBigUInt64LE(8)
-    const wait = WaitForSingleObject(hProcess, 30000)
-    const codeBuf = Buffer.alloc(4)
-    GetExitCodeProcess(hProcess, codeBuf)
-    const code = codeBuf.readUInt32LE(0)
-    CloseHandle(hThread); CloseHandle(hProcess)
-    results.push(`${v.label}: created=1 wait=${wait === 0 ? 'signaled' : 'timeout'} exit=${hexExit(code)}`)
-  } catch (e) {
-    results.push(`${v.label}: JS_ERROR ${e instanceof Error ? e.message : String(e)}`)
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-}
-
-async function main() {
-  console.log('=== win32 FFI debug matrix ===')
-  const hTokBuf = Buffer.alloc(8)
-  if (!OpenProcessToken(PSEUDO_CURRENT_PROCESS, 0x1 | 0x2 | 0x8, hTokBuf)) throw new Error('OpenProcessToken failed')
-  const hToken = hTokBuf.readBigUInt64LE(0)
-  const sidBuf = buildAdminSid()
-  const hRestrBuf = Buffer.alloc(8)
-  if (!CreateRestrictedToken(hToken, 0x1, 1, [{ Sid: sidBuf, Attributes: 0 }], 0, null, 0, null, hRestrBuf)) throw new Error('CreateRestrictedToken failed')
-  const hRestricted = hRestrBuf.readBigUInt64LE(0)
-  const execPath = process.execPath
-
-  const matrix: Variant[] = [
-    { label: '01 normal           cmd  nowin env=null  ', api: 'normal', token: 'plain', env: 'null', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '02 asUser   plain   cmd  nowin env=null  ', api: 'asUser', token: 'plain', env: 'null', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '03 asUser   plain   cmd  nowin env=block ', api: 'asUser', token: 'plain', env: 'block', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '04 asUser   plain   cmd  DETACH env=block ', api: 'asUser', token: 'plain', env: 'block', flags: DETACHED_PROCESS, program: 'cmd' },
-    { label: '05 asUser   plain   whoami nowin env=block', api: 'asUser', token: 'plain', env: 'block', flags: CREATE_NO_WINDOW, program: 'whoami' },
-    { label: '06 asUser   restr   cmd  nowin env=null  ', api: 'asUser', token: 'restricted', env: 'null', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '07 asUser   restr   cmd  nowin env=block ', api: 'asUser', token: 'restricted', env: 'block', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '08 asUser   restr   cmd  DETACH env=block ', api: 'asUser', token: 'restricted', env: 'block', flags: DETACHED_PROCESS, program: 'cmd' },
-    { label: '09 asUser   restr   whoami nowin env=block', api: 'asUser', token: 'restricted', env: 'block', flags: CREATE_NO_WINDOW, program: 'whoami' },
-    { label: '10 withToken plain  cmd  nowin env=block ', api: 'withToken', token: 'plain', env: 'block', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '11 withToken restr  cmd  nowin env=block ', api: 'withToken', token: 'restricted', env: 'block', flags: CREATE_NO_WINDOW, program: 'cmd' },
-    { label: '12 normal           node nowin env=null  ', api: 'normal', token: 'plain', env: 'null', flags: CREATE_NO_WINDOW, program: 'node' },
-    { label: '13 asUser   restr   node  nowin env=block', api: 'asUser', token: 'restricted', env: 'block', flags: CREATE_NO_WINDOW, program: 'node' },
-    { label: '14 asUser   restr   node DETACH env=block ', api: 'asUser', token: 'restricted', env: 'block', flags: DETACHED_PROCESS, program: 'node' },
-  ]
-  for (const v of matrix) await runVariant(v, hToken, hRestricted, execPath)
-  console.log(results.join('\n'))
-  CloseHandle(hRestricted); CloseHandle(hToken)
-}
-
-main().catch((e) => { console.error('FATAL:', e instanceof Error ? e.message : e); process.exitCode = 1 })