guanwei 1.3.2 → 1.3.4

package/scripts/github-history-cleanup.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// GitHub 仓库历史清理工具（可复用于任何仓库）
+//
+// 场景：用 git filter-repo 重写历史后，远端仍残留指向旧历史的 tag / release / 分支
+//      （尤其 immutable release 的 tag 会被 GitHub 永久绑定，无法用 git push 更新）。
+//
+// 用法：
+//   GITHUB_TOKEN=xxx node scripts/github-history-cleanup.mjs list   --repo owner/name
+//   GITHUB_TOKEN=xxx node scripts/github-history-cleanup.mjs purge  --repo owner/name --keep v1.3.4 [--apply]
+//   GITHUB_TOKEN=xxx node scripts/github-history-cleanup.mjs branches --repo owner/name [--apply]
+//
+//   token 读取顺序：--token-file > $GITHUB_TOKEN > internal/github-token（本地私有，git 忽略）
+//   默认 **dry-run**：不加 --apply 只打印将要执行的操作。
+import fs from 'node:fs';
+import path from 'node:path';
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+const arg = (name, def) => {
+  const i = argv.indexOf(name);
+  return i >= 0 && argv[i + 1] ? argv[i + 1] : def;
+};
+const has = (name) => argv.includes(name);
+const REPO = arg('--repo');
+const KEEP = (arg('--keep', '') || '').split(',').map(s => s.trim()).filter(Boolean);
+const APPLY = has('--apply');
+if (!REPO || !REPO.includes('/')) {
+  console.error('用法: node scripts/github-history-cleanup.mjs <list|purge|branches|releases> --repo owner/name [--keep tag,...] [--apply]');
+  process.exit(1);
+}
+const TOKEN = (() => {
+  const f = arg('--token-file');
+  const candidates = [f, process.env.GITHUB_TOKEN && '(env)', path.resolve('internal/github-token')].filter(Boolean);
+  if (f && fs.existsSync(f)) return fs.readFileSync(f, 'utf8').trim();
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN.trim();
+  const local = path.resolve('internal/github-token');
+  if (fs.existsSync(local)) return fs.readFileSync(local, 'utf8').trim();
+  console.error('缺少 token（--token-file / $GITHUB_TOKEN / internal/github-token 均不可用）', candidates);
+  process.exit(1);
+})();
+
+async function api(method, p, body) {
+  const res = await fetch('https://api.github.com' + p, {
+    method,
+    headers: {
+      Authorization: 'Bearer ' + TOKEN,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      ...(body ? { 'Content-Type': 'application/json' } : {}),
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  return { status: res.status, body: text ? JSON.parse(text) : null };
+}
+
+async function listAll(p) {
+  const out = [];
+  for (let page = 1; page <= 10; page++) {
+    const { status, body } = await api('GET', `${p}${p.includes('?') ? '&' : '?'}per_page=100&page=${page}`);
+    if (status !== 200 || !Array.isArray(body) || body.length === 0) break;
+    out.push(...body);
+    if (body.length < 100) break;
+  }
+  return out;
+}
+
+const info = async () => {
+  const { status, body } = await api('GET', `/repos/${REPO}`);
+  if (status !== 200) { console.error('仓库不可读:', status, body?.message); process.exit(1); }
+  return body;
+};
+
+const run = async () => {
+  const repo = await info();
+  const releases = await listAll(`/repos/${REPO}/releases`);
+  const tags = await listAll(`/repos/${REPO}/git/refs/tags`);
+  const branches = await listAll(`/repos/${REPO}/branches`);
+  const tagNames = tags.map(t => t.ref.replace('refs/tags/', ''));
+
+  if (cmd === 'list') {
+    console.log(`仓库 ${REPO}（默认分支 ${repo.default_branch}）`);
+    console.log(`  releases (${releases.length}):`, releases.map(r => `${r.tag_name}${r.immutable ? '(immutable)' : ''}`).join(', ') || '无');
+    console.log(`  tags (${tagNames.length}):`, tagNames.join(', ') || '无');
+    console.log(`  branches (${branches.length}):`, branches.map(b => b.name).join(', '));
+    const stale = tagNames.filter(t => !KEEP.includes(t));
+    console.log(`\n--keep 之外的 tag（purge 将删除其 release + tag）:`, stale.join(', ') || '无');
+    return;
+  }
+
+  if (cmd === 'branches') {
+    const stale = branches.map(b => b.name).filter(n => n !== repo.default_branch);
+    if (!stale.length) return console.log('无非默认分支');
+    for (const n of stale) {
+      if (!APPLY) { console.log(`[dry-run] 将删除分支 ${n}`); continue; }
+      const { status } = await api('DELETE', `/repos/${REPO}/git/refs/heads/${n}`);
+      console.log(`删除分支 ${n} → ${status}`);
+    }
+    return;
+  }
+
+  if (cmd === 'purge' || cmd === 'releases') {
+    // 防误删：未显式 --keep 时，默认保留「最新版本 tag」（latest release → semver 最大者）
+    let keep = [...KEEP];
+    if (keep.length === 0) {
+      const { body: latest } = await api('GET', `/repos/${REPO}/releases/latest`);
+      const cand = latest?.tag_name || tagNames
+        .slice()
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))
+        .pop();
+      if (cand) { keep = [cand]; console.log(`（未指定 --keep，默认保留最新版本 ${cand}）`); }
+    }
+    const staleTags = tagNames.filter(t => !keep.includes(t));
+    const byTag = new Map(releases.map(r => [r.tag_name, r]));
+    for (const t of staleTags) {
+      const rel = byTag.get(t);
+      if (rel) {
+        if (!APPLY) console.log(`[dry-run] 将删除 release ${t}${rel.immutable ? '（immutable）' : ''} + tag ${t}`);
+        else {
+          const d1 = await api('DELETE', `/repos/${REPO}/releases/${rel.id}`);
+          const d2 = await api('DELETE', `/repos/${REPO}/git/refs/tags/${t}`);
+          console.log(`删除 ${t}: release=${d1.status} tag=${d2.status}`);
+        }
+      } else if (cmd === 'purge') {
+        if (!APPLY) console.log(`[dry-run] 将删除 tag ${t}（无 release）`);
+        else {
+          const d = await api('DELETE', `/repos/${REPO}/git/refs/tags/${t}`);
+          console.log(`删除 tag ${t} → ${d.status}`);
+        }
+      }
+    }
+    if (!APPLY) console.log(`\n共 ${staleTags.length} 个待处理；确认后加 --apply 执行`);
+    return;
+  }
+
+  console.error('未知子命令:', cmd);
+  process.exit(1);
+};
+
+run().catch(e => { console.error('执行失败:', e.message); process.exit(1); });

package/scripts/npm-release.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// npm 发布工具（读本地凭据 → 校验 → 包内容守卫 → 发布）
+//
+// 用法：
+//   node scripts/npm-release.mjs --check            # 只校验凭据与登录态（不发布）
+//   node scripts/npm-release.mjs --dry-run          # 走一遍打包与守卫，不真正发布
+//   node scripts/npm-release.mjs                    # 正式发布（用 internal/.env 的 NPM_TOKEN）
+//   node scripts/npm-release.mjs --otp 123456       # 用动态码（无 Automation token 时）
+//
+// 为什么需要它：npm 不读 .env；本脚本把 internal/.env 的 NPM_TOKEN 注入临时 .npmrc 后调用 npm。
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadCredentials, CRED_FILES } from './credentials.mjs';
+
+const argv = process.argv.slice(2);
+const has = (f) => argv.includes(f);
+const val = (f) => { const i = argv.indexOf(f); return i >= 0 ? argv[i + 1] : ''; };
+const REGISTRY = 'https://registry.npmjs.org';
+const ROOT = process.cwd();
+
+const { NPM_TOKEN } = loadCredentials();
+const otp = val('--otp');
+
+async function whoami(token) {
+  const res = await fetch(`${REGISTRY}/-/whoami`, { headers: token ? { Authorization: 'Bearer ' + token } : {} });
+  if (!res.ok) return null;
+  return (await res.json()).username;
+}
+
+const run = async () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  console.log(`包 ${pkg.name}@${pkg.version} → ${REGISTRY}`);
+
+  // 1) 凭据检查
+  let user = null;
+  if (NPM_TOKEN) {
+    user = await whoami(NPM_TOKEN);
+    console.log(`NPM_TOKEN 校验: ${user ? '✅ 有效（账号 ' + user + '）' : '❌ 无效/已撤销'}`);
+    if (!user) process.exit(1);
+  } else {
+    console.log(`未找到 NPM_TOKEN（可写入 ${CRED_FILES.env} 或 ${CRED_FILES.npm}）`);
+    user = await whoami('');   // 回退系统 ~/.npmrc
+    console.log(`系统 npm 登录态: ${user ? '✅ ' + user : '❌ 未登录/已失效'}`);
+    if (!user && !otp) { console.error('既无 NPM_TOKEN 也无有效登录态 → 无法发布'); process.exit(1); }
+  }
+  if (has('--check')) return;
+
+  // 2) 包内容守卫（硬门槛）
+  if (!has('--skip-guard')) {
+    console.log('包内容守卫...');
+    execFileSync('node', ['scripts/check-package.mjs'], { stdio: 'inherit' });
+  }
+
+  // 3) 临时 userconfig（仅当使用 NPM_TOKEN）
+  let cfgPath = '';
+  if (NPM_TOKEN) {
+    cfgPath = path.join(ROOT, 'internal', '.npmrc');
+    fs.writeFileSync(cfgPath, `registry=${REGISTRY}\n//registry.npmjs.org/:_authToken=\${NPM_TOKEN}\n`);
+    fs.chmodSync(cfgPath, 0o600);
+  }
+
+  // 4) 发布
+  const args = ['publish', '--registry', REGISTRY];
+  if (cfgPath) args.push('--userconfig', cfgPath);
+  if (otp) args.push('--otp', String(otp));
+  if (has('--dry-run')) args.push('--dry-run');
+  console.log('执行: npm ' + args.join(' '));
+  const r = spawnSync('npm', args, {
+    stdio: 'inherit',
+    env: { ...process.env, ...(NPM_TOKEN ? { NPM_TOKEN } : {}), npm_config_cache: path.join(ROOT, '.npm-cache') },
+  });
+  if (cfgPath) { try { fs.unlinkSync(cfgPath); } catch { /* ignore */ } }
+  try { fs.rmSync(path.join(ROOT, '.npm-cache'), { recursive: true, force: true }); } catch { /* ignore */ }
+  if (r.status !== 0) { console.error('❌ 发布失败（退出码 ' + r.status + '）'); process.exit(r.status || 1); }
+  console.log('✅ 发布完成');
+};
+
+run().catch(e => { console.error('执行失败:', e.message); process.exit(1); });

package/scripts/preflight-release.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# 发版前自检（本地硬门槛）：内容干净 + 测试通过 + 版本一致
+# 用法：./scripts/preflight-release.sh [期望版本号]
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+echo "1/5 仓库边界守卫（公开区不得含内部内容；打包区须为公开区子集）..."
+node scripts/check-boundary.mjs
+
+echo "2/5 包内容守卫（文件名 + 内容级扫描，拒绝任何运行时数据/密钥）..."
+node scripts/check-package.mjs
+
+echo "3/5 类型检查..."
+npx tsc --noEmit
+(cd server && npx tsc --noEmit)
+
+echo "4/5 全量测试..."
+npx vitest run --reporter=dot >/tmp/gw-preflight-test.log 2>&1 || { echo "✗ 测试未通过，见 /tmp/gw-preflight-test.log"; tail -20 /tmp/gw-preflight-test.log; exit 1; }
+grep -E "Test Files|Tests " /tmp/gw-preflight-test.log | tail -2
+
+echo "5/5 版本一致性..."
+V=$(node -e "console.log(require('./package.json').version)")
+for f in server/package.json packages/guanwei-api/package.json package-lock.json server/package-lock.json; do
+  Vf=$(node -e "const d=require('./$f');console.log(d.version||d.packages?.['']?.version||'?')")
+  [ "$Vf" = "$V" ] || { echo "✗ 版本漂移：$f = $Vf，根 = $V"; exit 1; }
+done
+grep -q "version: '$V'" packages/guanwei-api/src/mcp.ts || echo "⚠️  MCP serverInfo.version 未同步到 $V"
+if [ -n "${1:-}" ] && [ "$1" != "$V" ]; then echo "✗ 参数版本 $1 ≠ package.json $V"; exit 1; fi
+echo "✅ 自检通过：v$V 可发布"

package/scripts/release.sh

@@ -4,7 +4,7 @@
 # 用法：./scripts/release.sh 1.1.2            仅 git 发版（tag 触发 CI/Release/镜像）
 #       ./scripts/release.sh 1.1.2 --npm      额外发布 npm 包（需先配置 npm 登录）
 # 要求：工作区无未提交改动；CHANGELOG.md 已写好本次版本条目
-# 详见（本地文档，不入库）：docs/RELEASE-SOP.md（发版 SOP 详情/踩坑记录）
+# 详见（本地文档，不入库）：internal/docs/RELEASE-SOP.md（发版 SOP 详情/踩坑记录）
 # ============================================================
 set -euo pipefail
 cd "$(dirname "$0")/.."
@@ -54,7 +54,12 @@ fi
 
 echo "3️⃣  提交 + 打 tag + 推送 git"
 git add package.json package-lock.json server/package.json server/package-lock.json CHANGELOG.md
-git commit -m "chore: 版本升级 ${NEW_VER}"
+# 版本号/CHANGELOG 已在之前提交中就位时，此处无暂存差异——跳过提交，避免 set -e 中断发版
+if git diff --cached --quiet; then
+  echo "   ℹ️  版本文件无变化（已在历史提交中就位），跳过版本提交"
+else
+  git commit -m "chore: 版本升级 ${NEW_VER}"
+fi
 # 提交后再次校验：确保 tag 一定落在版本号已落地的 commit 上
 HEAD_VER="$(node -e "console.log(require('./package.json').version)")"
 if [[ "$HEAD_VER" != "$NEW_VER" ]]; then
@@ -70,7 +75,7 @@ echo "   ✅ 已推送——CI / Release / 镜像 / Pages 将自动执行"
 if [[ "$DO_NPM" == "1" ]]; then
   echo "4️⃣  发布 npm（registry 必须是官方源，本机默认 npmmirror 需显式指定）..."
   # 用本地缓存避免 ~/.npm 写入受限；发布失败不中断后续提示
-  npm publish --registry https://registry.npmjs.org --cache ./.npm-cache || echo "   ⚠️  npm publish 失败——按 docs/RELEASE-SOP.md 第四节排查（2FA/权限/registry）"
+  npm publish --registry https://registry.npmjs.org --cache ./.npm-cache || echo "   ⚠️  npm publish 失败——按 internal/docs/RELEASE-SOP.md 第四节排查（2FA/权限/registry）"
   rm -rf .npm-cache
   echo "5️⃣  验证线上版本..."
   npm view guanwei version --registry https://registry.npmjs.org --cache ./.npm-cache 2>/dev/null || true

package/server/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "guanwei-server",
+  "version": "1.3.4",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  }
+}

package/server/src/index.ts

@@ -18,11 +18,8 @@ import { fileURLToPath } from 'url';
       if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;        // 非法键名 → 跳过
       if (process.env[key] !== undefined) continue;               // 环境变量优先，不覆盖
       let val = line.slice(eq + 1).trim();
-      // 行内注释剥离（引号外的 # 视为注释起点）
-      if (!val.startsWith('"') && !val.startsWith("'")) {
-        const hash = val.indexOf(' #');
-        if (hash >= 0) val = val.slice(0, hash);
-      }
+      // 注：仅支持「整行注释」（行首 #）。不做行内注释剥离——API Key 可能含「 #」，
+      // 原实现会把密钥截断且仍报「已配置」，故障延后到运行期 401（2026-09 修 P1-5）
       // 引号包裹 → 整体剥引号 + 处理转义（仅双引号内做转义展开）
       const q = val.startsWith('"') ? '"' : val.startsWith("'") ? "'" : null;
       if (q && val.endsWith(q) && val.length >= 2) {
@@ -46,18 +43,38 @@ import aiRouter from './routes/ai.js';
 import usersRouter from './routes/users.js';
 import divineRouter from './routes/divine.js';
 import hourRouter from './routes/hour.js';
+import { DATA_DIR } from './services/dataDir.js';
 
 const app = express();
 const PORT = process.env.PORT || 3018;
+// 默认只绑本机（个人自托管场景）；容器/局域网部署用 HOST=0.0.0.0 显式放开
+const HOST = process.env.HOST || '127.0.0.1';
+// 反代（nginx/Docker）后取真实客户端 IP：否则限流键恒为网关地址，退化为全站单桶（2026-09 修 P1-2）
+app.set('trust proxy', 'loopback, linklocal, uniquelocal');
 
-app.use(cors());
+// CORS：默认仅同源/本机（原 `cors()` 全开，配合匿名占位账号放行可被任意站点跨源读取，2026-09 修 P2-1）
+// 需要放开时设 GUANWEI_ALLOWED_ORIGINS=https://a.com,https://b.com
+const ALLOWED = (process.env.GUANWEI_ALLOWED_ORIGINS || '').split(',').map(x => x.trim()).filter(Boolean);
+app.use(cors({
+  origin(origin: string | undefined, cb: (e: Error | null, ok?: boolean) => void) {
+    if (!origin) return cb(null, true);                       // 同源/服务端调用
+    if (ALLOWED.length === 0) {
+      const local = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/.test(origin);
+      return cb(null, local);                                  // 未配置 → 仅本机前端
+    }
+    return cb(null, ALLOWED.includes(origin));
+  },
+}));
 app.use(express.json());
 
-// ─── 限流（防 BYOK Key 被刷爆 / 无限建占刷库）：per-IP 令牌桶 ───
+// ─── 限流（防 BYOK Key 被刷爆 / 无限建占刷库）：per-IP + per-路由组 令牌桶 ───
 // /api/ai：每分钟 30 次（AI 烧 token，重点防护）
 // /api/divine 写：每分钟 60 次（防无限建占刷 SQLite）
-const AI_RATE_LIMIT = { windowMs: 60_000, max: 30 };
-const DIVINE_RATE_LIMIT = { windowMs: 60_000, max: 60 };
+// 2026-09 修 P1-1：桶键含路由组——原实现单 Map 仅按 IP 计数，
+// 用户连续起占 31 次会把首个 AI 解读请求顶成 429（跨路由互相误伤）
+const RATE_ENV = (k: string, d: number) => Number(process.env[k] || d);
+const AI_RATE_LIMIT = { windowMs: 60_000, max: RATE_ENV('GUANWEI_RATE_AI', 30) };
+const DIVINE_RATE_LIMIT = { windowMs: 60_000, max: RATE_ENV('GUANWEI_RATE_DIVINE', 60) };
 const hits = new Map<string, { count: number; resetAt: number }>();
 // 定期清理过期桶（防内存泄漏，M-NEW3）
 setInterval(() => {
@@ -65,13 +82,14 @@ setInterval(() => {
   for (const [k, v] of hits) if (now > v.resetAt) hits.delete(k);
 }, 10 * 60 * 1000).unref();
 
-function rateLimit(limit: { windowMs: number; max: number }) {
+function rateLimit(group: string, limit: { windowMs: number; max: number }) {
   return (req: any, res: any, next: any) => {
     const ip = req.ip || req.socket.remoteAddress || 'unknown';
+    const key = group + ':' + ip;
     const now = Date.now();
-    const rec = hits.get(ip);
+    const rec = hits.get(key);
     if (!rec || now > rec.resetAt) {
-      hits.set(ip, { count: 1, resetAt: now + limit.windowMs });
+      hits.set(key, { count: 1, resetAt: now + limit.windowMs });
       return next();
     }
     rec.count++;
@@ -81,11 +99,20 @@ function rateLimit(limit: { windowMs: number; max: number }) {
     next();
   };
 }
-app.use('/api/ai', rateLimit(AI_RATE_LIMIT));
+app.use('/api/ai', rateLimit('ai', AI_RATE_LIMIT));
 app.use('/api/divine', (req, res, next) => {
   if (req.method === 'GET') return next();  // 读操作不限制
-  return rateLimit(DIVINE_RATE_LIMIT)(req, res, next);
+  return rateLimit('divine', DIVINE_RATE_LIMIT)(req, res, next);
 });
+// 登录/注册：更严阈值（防口令爆破与脚本化抢注，2026-09 修 P1-3）
+const AUTH_RATE_LIMIT = { windowMs: 60_000, max: RATE_ENV('GUANWEI_RATE_AUTH', 10) };
+const GENERIC_LIMIT = { windowMs: 60_000, max: RATE_ENV('GUANWEI_RATE_GENERIC', 120) };
+app.use('/api/users/login', rateLimit('login', AUTH_RATE_LIMIT));
+app.use('/api/users/register', rateLimit('register', AUTH_RATE_LIMIT));
+app.use('/api/users', rateLimit('users', GENERIC_LIMIT));
+// 其余匿名计算端点（原不在任何桶内 → 可被无上限刷，2026-09 修 P0-5/P2-7）
+app.use('/api/tarot', rateLimit('tarot', GENERIC_LIMIT));
+app.use('/api/hour', rateLimit('hour', GENERIC_LIMIT));
 
 // 请求日志（联调排查用）
 app.use((req, res, next) => {
@@ -106,7 +133,10 @@ app.get('/api', (_req, res) => {
 });
 
 app.get('/api/health', (_req, res) => {
-  res.json({ status: 'ok', timestamp: Date.now() });
+  // 轻量自检：数据目录可写 + LLM 配置状态（不含敏感值）
+  let dataDirOk = true;
+  try { fs.accessSync(DATA_DIR, fs.constants.W_OK); } catch { dataDirOk = false; }
+  res.json({ status: dataDirOk ? 'ok' : 'degraded', dataDir: dataDirOk ? 'ok' : 'readonly', timestamp: Date.now() });
 });
 
 app.use('/api/tarot', tarotRouter);
@@ -115,7 +145,19 @@ app.use('/api/users', usersRouter);
 app.use('/api/divine', divineRouter);
 app.use('/api', hourRouter);
 
-app.listen(PORT, () => {
+// 统一错误处理（2026-09 修 P1-1）：JSON 解析失败/未捕获异常一律返回 JSON，
+// 且不把堆栈与绝对路径回给客户端（原实现由 Express 默认处理器返回 HTML 堆栈页）
+app.use((err: any, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+  const status = err?.status || err?.statusCode || 500;
+  const isJsonErr = err?.type === 'entity.parse.failed';
+  if (status >= 500) console.error('[server] 未处理异常:', err?.message || err);
+  res.status(status).json({
+    error: isJsonErr ? 'BAD_JSON' : (err?.code || 'INTERNAL'),
+    message: isJsonErr ? '请求体不是合法 JSON' : (status >= 500 ? '服务暂时不可用' : (err?.message || '请求有误')),
+  });
+});
+
+app.listen(Number(PORT), HOST, () => {
   console.log(`
   🎴 观微后端服务已启动
   

package/server/src/routes/ai.ts

@@ -1,8 +1,8 @@
 // AI 解读路由：/api/ai/interpret（非流式）+ /api/ai/interpret/stream（SSE）
 import { Router } from 'express';
-import fs from 'fs';
+import { resolveTokenUser, allowAnonymous } from '../services/auth.js';
+import { readUsersDb } from '../services/usersDb.js';
 import path from 'path';
-import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 import { buildMessages, buildReportMessages, buildStep1Messages, buildStep2Messages } from '../services/promptBuilder.js';
 import { chatOnce, chatStream, activeProvider, providerStatus, lastFinishReason } from '../services/llmProvider.js';
@@ -13,29 +13,23 @@ import { MINGPAN_TEMPLATE } from '../services/promptBuilder.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-// 请求 token → 用户名（与 divine.ts 同策略：有 token 以 token 为准，防 body 自报他人名）
+// 请求 token → 用户名（统一走 services/auth：含 tokenExpires 校验，2026-09 修 P1-1）
 function authedUsername(req: any): string | null {
-  const tk = String(req.headers['x-guanwei-token'] || '');
-  if (!tk) return null;
-  try {
-    const db = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'data', 'db.json'), 'utf-8'));
-    const user = db.users.find((u: any) => u.token && u.token.length === tk.length && crypto.timingSafeEqual(Buffer.from(u.token), Buffer.from(tk)));
-    return user ? user.username : null;
-  } catch { return null; }
+  return resolveTokenUser(req)?.username ?? null;
 }
 
 
-// 解读归属校验（与 divine.resolveOwner 同策略）：正式账号须本人 token，占位账号兼容无 token
+// 解读归属校验：正式账号须本人 token；占位账号仅限「可信内网来源」无 token 访问
+// （2026-09 修 P0-2：原实现 catch 分支 fail-open，读库失败即放行，配合无鉴权建档可跨用户读档案/耗 AI 额度）
 function canReadChart(req: any, recUsername: string, fallbackUsername: string): boolean {
   const authed = authedUsername(req);
   if (authed) return authed === recUsername;
-  // 无 token：仅当目标是占位账号（未正式注册）时允许 fallback username
-  if (fallbackUsername && fallbackUsername !== recUsername) return false;
+  if (!allowAnonymous(req)) return false;                       // 公网来源必须带 token
+  if (fallbackUsername && fallbackUsername !== recUsername) return false;  // 不得自报他人名号
   try {
-    const db = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'data', 'db.json'), 'utf-8'));
-    const user = db.users.find((u: any) => u.username === recUsername);
-    return !user || !user.passHash;  // 占位账号放行
-  } catch { return true; }
+    const user = readUsersDb().users.find((u: any) => u.username === recUsername);
+    return !user || !user.passHash;                             // 占位账号放行（内网）
+  } catch { return false; }                                     // 读库失败一律拒绝（不再 fail-open）
 }
 
 // 非流式：token 优先归属

package/server/src/routes/divine.ts

@@ -2,30 +2,38 @@
 import { Router } from 'express';
 import { chartCalc } from '../../../shared/core/engine/chart.js';
 import { createDivination, listDivinations, getDivination, deleteDivination } from '../services/divineStore.js';
+import { resolveTokenUser, allowAnonymous } from '../services/auth.js';
+import { readUsersDb, withUsersDb } from '../services/usersDb.js';
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DB_FILE = path.join(__dirname, '..', 'data', 'db.json');
+// 用户档案库路径与读写统一由 services/usersDb 提供（默认 server/data/db.json，
+// 可用 GUANWEI_USERS_DB / GUANWEI_DATA_DIR 覆盖；原子写 + 进程内串行锁）
+
+// 用户库读写统一走 services/usersDb（进程内串行锁 + 临时文件原子替换）
+function loadUsersDb(): any { return readUsersDb(); }
 
 const router = Router();
 const MINGPAN_ARTS = ['bazi', 'ziwei', 'astrology'];
 
-// 宽松建档：前端本地注册的用户在此同步建档（与 users.ts upsert 同策略；建档即发 claimToken 防抢占）
-// 返回 null=失败；否则 { existed: 是否已存在, claimToken: 该账号当前 token（新建时返回，供前端保存用于后续注册升级）}
-function ensureUser(username: string): { existed: boolean; claimToken: string } | null {
+// 宽松建档：前端本地注册的用户在此同步建档（与 users.ts upsert 同策略；新建时发 claimToken 防抢占）
+// 返回 null=失败；否则 { existed, claimToken }
+// 安全（2026-09 修 P0-1）：claimToken 只在「本次新建」时返回，绝不回吐已存在账号的 token——
+// 否则任何人只要知道 username 即可取走占位账号凭据并 register 抢占（含档案/起占历史）。
+async function ensureUser(username: string): Promise<{ existed: boolean; claimToken: string } | null> {
   if (!username || typeof username !== 'string') return null;
   try {
-    const db = JSON.parse(fs.readFileSync(DB_FILE, 'utf-8'));
-    const exist = db.users.find((u: any) => u.username === username);
-    if (exist) return { existed: true, claimToken: exist.token || '' };
-    const token = crypto.randomBytes(32).toString('hex');
-    db.users.push({ username, passHash: '', createdAt: Date.now(), profile: {}, samples: [], records: [], token, tokenExpires: Date.now() + 30 * 24 * 3600 * 1000 });
-    fs.writeFileSync(DB_FILE, JSON.stringify(db, null, 2));
-    console.log('[divine] 自动建档:', username);
-    return { existed: false, claimToken: token };
+    return await withUsersDb((db) => {
+      const exist = db.users.find((u: any) => u.username === username);
+      if (exist) return { existed: true, claimToken: '' };   // 已存在账号绝不回吐 token（P0-1）
+      const token = crypto.randomBytes(32).toString('hex');
+      db.users.push({ username, passHash: '', createdAt: Date.now(), profile: {}, samples: [], records: [], token, tokenExpires: Date.now() + 30 * 24 * 3600 * 1000 });
+      console.log('[divine] 自动建档:', username);
+      return { existed: false, claimToken: token };
+    });
   } catch (e: any) {
     console.error('[divine] ensureUser 异常:', e?.message || e);
     return null;
@@ -34,13 +42,7 @@ function ensureUser(username: string): { existed: boolean; claimToken: string }
 
 // 请求携带的 token → 对应用户名（有 token 则以其为准，堵「query/body 自报 username」越权）
 function authedUsername(req: any): string | null {
-  const tk = String(req.headers['x-guanwei-token'] || '');
-  if (!tk) return null;
-  try {
-    const db = JSON.parse(fs.readFileSync(DB_FILE, 'utf-8'));
-    const user = db.users.find((u: any) => u.token && u.token.length === tk.length && crypto.timingSafeEqual(Buffer.from(u.token), Buffer.from(tk)));
-    return user ? user.username : null;
-  } catch { return null; }
+  return resolveTokenUser(req)?.username ?? null;
 }
 
 // 归属校验统一入口：
@@ -51,12 +53,16 @@ function authedUsername(req: any): string | null {
 // 返回 { owner, isPlaceholder }；null = 校验失败（已 res 响应）
 function resolveOwner(req: any, res: any, fallbackUsername: string): { owner: string; isPlaceholder: boolean } | null {
   const authed = authedUsername(req);
+  // 匿名来源限制（P0-3）：公网来源必须持 token；仅回环/内网允许无 token 的本地流程
+  if (!authed && !allowAnonymous(req)) {
+    res.status(401).json({ error: 'AUTH_REQUIRED', message: '请先入馆（登录）后操作（公网访问不开放匿名起占）' });
+    return null;
+  }
   let owner = authed || String(fallbackUsername || '');
   if (!owner) { res.status(401).json({ error: 'UNAUTHORIZED', message: '请先入馆（登录）' }); return null; }
   let user: any = null;
   try {
-    const db = JSON.parse(fs.readFileSync(DB_FILE, 'utf-8'));
-    user = db.users.find((u: any) => u.username === owner) || null;
+    user = loadUsersDb().users.find((u: any) => u.username === owner) || null;
   } catch { /* 读失败按占位处理 */ }
   const isPlaceholder = !user || !user.passHash;
   if (!authed && !isPlaceholder) {
@@ -68,16 +74,16 @@ function resolveOwner(req: any, res: any, fallbackUsername: string): { owner: st
 }
 
 // POST /api/divine —— 起占入库
-router.post('/', (req, res) => {
+router.post('/', async (req, res) => {
   const { artId, inputs, profile, question, username, profileId } = req.body || {};
   const resolved = resolveOwner(req, res, String(username || ''));
   if (!resolved) return;
   const owner = resolved.owner;
-  const ensured = ensureUser(owner);
+  const ensured = await ensureUser(owner);
   if (!ensured) {
     return res.status(401).json({ error: 'UNAUTHORIZED', message: '请先入馆（登录）再起占' });
   }
-  const claimToken = ensured.claimToken;  // 新建占位账号时返回，供前端保存（L-NEW1）
+  const claimToken = ensured.claimToken;  // 仅「本次新建」时非空（P0-1）
   if (!artId || !inputs) return res.status(400).json({ error: '缺少必要参数' });
 
   let resultRaw: unknown;
@@ -101,19 +107,19 @@ router.post('/', (req, res) => {
   const authed = authedUsername(req);
   res.json({
     ok: true, divineId: rec.id, resultRaw, display: rec.display,
-    // L-NEW1：请求未带 token（本地占位流程）→ 返回 claimToken，前端保存后注册可升级；带 token 则无需
-    claimToken: authed ? undefined : ensured.claimToken,
+    // L-NEW1：仅未鉴权 + 本次新建占位账号时返回 claimToken（前端保存后注册可升级）；已存在账号一律不回吐
+    claimToken: (!authed && !ensured.existed && claimToken) ? claimToken : undefined,
   });
 });
 
 // GET /api/divine?username=&page=&pageSize= —— 占卜历史（H-NEW2：正式账号须本人 token）
-router.get('/', (req, res) => {
+router.get('/', async (req, res) => {
   const username = String(req.query.username || '');
   const page = Number(req.query.page || 1);
   const pageSize = Number(req.query.pageSize || 20);
   const resolved = resolveOwner(req, res, username);
   if (!resolved) return;
-  if (!ensureUser(resolved.owner)) return res.status(401).json({ error: 'UNAUTHORIZED' });
+  if (!(await ensureUser(resolved.owner))) return res.status(401).json({ error: 'UNAUTHORIZED' });
   res.json(listDivinations(resolved.owner, page, pageSize, String(req.query.profileId || '')));
 });
 
@@ -124,7 +130,8 @@ router.get('/:id', (req, res) => {
   // 归属校验：token 优先；无 token 仅占位账号可经 query username 访问
   const resolved = resolveOwner(req, res, String(req.query.username || ''));
   if (!resolved) return;
-  if (resolved.owner !== rec.username) return res.status(403).json({ error: 'FORBIDDEN' });
+  // 归属不符统一返回 404（原 403/404 差异可枚举 divineId 存在性，2026-09 修 P1-7）
+  if (resolved.owner !== rec.username) return res.status(404).json({ error: 'DIVINE_NOT_FOUND' });
   res.json({ ...rec, resultRaw: rec.resultRaw, display: rec.display, report: rec.report || null });
 });
 

package/server/src/routes/hour.ts

@@ -12,6 +12,10 @@ router.post('/hour-infer', (req, res) => {
   if (!Array.isArray(events) || events.length === 0) {
     return res.status(400).json({ error: '请至少提供一条关键人生事件' });
   }
+  // 条数上限（2026-09 修 P2-7）：每条事件会触发 12 候选 × baziCalc，原无上限可被放大
+  if (events.length > 50) {
+    return res.status(400).json({ error: 'TOO_MANY_EVENTS', message: '关键事件请控制在 50 条以内' });
+  }
   const cleanEvents: HourInferEvent[] = events
     .map((e: any) => ({
       year: Number(e?.year),