guanwei 1.3.1 → 1.3.4

package/server/src/routes/tarot.ts

@@ -21,7 +21,12 @@ router.post('/draw', (req, res) => {
   let spread: Spread | undefined;
   
   if (customSpread) {
-    spread = customSpread;
+    // 自定义牌阵限长（2026-09 修 P0-5）：原实现按 positions.length 无上限循环，可被 10 万项拖死
+    const pos = Array.isArray(customSpread?.positions) ? customSpread.positions : [];
+    if (pos.length === 0 || pos.length > 20) {
+      return res.status(400).json({ error: 'BAD_SPREAD', message: '自定义牌阵位数为 1-20' });
+    }
+    spread = { ...customSpread, positions: pos.slice(0, 20) } as Spread;
   } else {
     spread = defaultSpreads.find(s => s.id === spreadId);
   }
@@ -41,10 +46,17 @@ router.post('/interpret', (req, res) => {
     return res.status(400).json({ error: '缺少必要参数' });
   }
   
+  // 抽牌/解读入参限长（同上）
+  if (!Array.isArray(cards) || cards.length === 0 || cards.length > 20) {
+    return res.status(400).json({ error: 'BAD_CARDS', message: '牌数需为 1-20' });
+  }
+  if (String(question).length > 300) {
+    return res.status(400).json({ error: 'BAD_QUESTION', message: '所问之事请控制在 300 字以内' });
+  }
   const result = generateInterpretation(
-    cards,
-    spread,
-    question,
+    cards.slice(0, 20),
+    { ...spread, positions: (spread.positions || []).slice(0, 20) },
+    String(question).slice(0, 300),
     category as QuestionCategory
   );
   
@@ -69,13 +81,22 @@ router.post('/interpret/stream', (req, res) => {
     return res.status(400).json({ error: '缺少必要参数' });
   }
   
+  // 抽牌/解读入参限长（同上）
+  if (!Array.isArray(cards) || cards.length === 0 || cards.length > 20) {
+    return res.status(400).json({ error: 'BAD_CARDS', message: '牌数需为 1-20' });
+  }
+  if (String(question).length > 300) {
+    return res.status(400).json({ error: 'BAD_QUESTION', message: '所问之事请控制在 300 字以内' });
+  }
   const result = generateInterpretation(
-    cards,
-    spread,
-    question,
+    cards.slice(0, 20),
+    { ...spread, positions: (spread.positions || []).slice(0, 20) },
+    String(question).slice(0, 300),
     category as QuestionCategory
   );
   
+  let closed = false;
+  req.on('close', () => { closed = true; });   // 客户端断开 → 停止逐字推送（修 P3-2）
   res.setHeader('Content-Type', 'text/event-stream');
   res.setHeader('Cache-Control', 'no-cache');
   res.setHeader('Connection', 'keep-alive');
@@ -83,6 +104,7 @@ router.post('/interpret/stream', (req, res) => {
   let sectionIndex = 0;
   
   const sendSection = () => {
+    if (closed) return;                              // 客户端已断开：停止计时器链
     if (sectionIndex >= result.sections.length) {
       res.write('event: done\n');
       res.write('data: [DONE]\n\n');
@@ -95,6 +117,7 @@ router.post('/interpret/stream', (req, res) => {
     let charIndex = 0;
     
     const typeChar = () => {
+      if (closed) return;                            // 同上
       if (charIndex >= chars.length) {
         sectionIndex++;
         setTimeout(sendSection, 300);

package/server/src/routes/users.ts

@@ -4,9 +4,12 @@ import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
 import { fileURLToPath } from 'url';
+import { USERS_DB } from '../services/dataDir.js';
+import { readUsersDb, writeUsersDb, withUsersDb } from '../services/usersDb.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DB_FILE = path.join(__dirname, '..', 'data', 'db.json');
+// 用户档案 JSON 库：默认 server/data/db.json（运行时目录，与源码分离，绝不入 npm 包）
+const DB_FILE = USERS_DB;
 
 function scryptAsync(pw: string, salt: Buffer, keylen: number): Promise<Buffer> {
   return new Promise((resolve, reject) => {
@@ -29,14 +32,53 @@ interface DbUser {
 
 interface Db { users: DbUser[] }
 
-function loadDb(): Db {
-  try { return JSON.parse(fs.readFileSync(DB_FILE, 'utf-8')); }
-  catch { return { users: [] }; }
-}
+// 读写统一走 services/usersDb：原子写（临时文件 + rename），避免半截文件把全库读成空库
+function loadDb(): Db { return readUsersDb() as Db; }
+function saveDb(db: Db): void { writeUsersDb(db); }
+
+// ─── 输入校验（2026-09 安全修复）───
+// profile/records 原样入库会被后续注入 AI prompt 并落盘；此处白名单化 + 拒绝原型污染键
+const DANGEROUS_KEYS = ['__proto__', 'constructor', 'prototype'];
 
-function saveDb(db: Db): void {
-  fs.mkdirSync(path.dirname(DB_FILE), { recursive: true });
-  fs.writeFileSync(DB_FILE, JSON.stringify(db, null, 2));
+function isSafeKey(k: string): boolean { return !DANGEROUS_KEYS.includes(k); }
+function cleanString(v: unknown, max = 200): string {
+  return typeof v === 'string' ? v.slice(0, max) : '';
+}
+/** 出生档案白名单校验：仅保留已知字段，限制长度/数值范围 */
+function sanitizeProfile(input: any): Record<string, unknown> | null {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return null;
+  const p = input as Record<string, any>;
+  const out: Record<string, unknown> = {};
+  if (typeof p.birthDate === 'string' && /^\d{4}-\d{1,2}-\d{1,2}$/.test(p.birthDate)) out.birthDate = p.birthDate.slice(0, 10);
+  if (typeof p.birthTime === 'string' && /^\d{1,2}:\d{2}$/.test(p.birthTime)) out.birthTime = p.birthTime.slice(0, 5);
+  if (Number.isInteger(p.birthHourIndex) && p.birthHourIndex >= -1 && p.birthHourIndex <= 11) out.birthHourIndex = p.birthHourIndex;
+  if (typeof p.birthTimeUnknown === 'boolean') out.birthTimeUnknown = p.birthTimeUnknown;
+  if (p.gender === '男' || p.gender === '女') out.gender = p.gender;
+  if (p.location && typeof p.location === 'object' && !Array.isArray(p.location)) {
+    const l = p.location as Record<string, any>;
+    const lng = Number(l.lng), lat = Number(l.lat);
+    if (Number.isFinite(lng) && lng >= -180 && lng <= 180 && Number.isFinite(lat) && lat >= -90 && lat <= 90) {
+      out.location = { province: cleanString(l.province, 40), city: cleanString(l.city, 40), district: cleanString(l.district, 40), lng, lat };
+    }
+  }
+  if (Array.isArray(p.lifeEvents)) {
+    out.lifeEvents = p.lifeEvents.slice(0, 50)
+      .filter((e: any) => e && typeof e === 'object' && Number.isInteger(e.year) && e.year >= 1900 && e.year <= 2200)
+      .map((e: any) => ({ year: e.year, text: cleanString(e.text, 200) }));
+  }
+  for (const k of Object.keys(out)) if (!isSafeKey(k)) delete out[k];
+  if (JSON.stringify(out).length > 20000) return null;
+  return out;
+}
+/** 记录同步校验：整表覆盖须限条数与单条体积 */
+function sanitizeRecords(input: any): Record<string, unknown>[] | null {
+  if (!Array.isArray(input)) return null;
+  if (input.length > 2000) return null;
+  for (const item of input) {
+    if (item && typeof item === 'object' && JSON.stringify(item).length > 20000) return null;
+    if (item && typeof item === 'object' && Object.keys(item).some(k => !isSafeKey(k))) return null;
+  }
+  return input;
 }
 
 // 密码哈希：scrypt（带随机盐，防彩虹表/暴力破解）。
@@ -100,50 +142,55 @@ router.post('/register', async (req, res) => {
   const { username, password, profile } = req.body;
   const name = String(username || '').trim();
   if (name.length < 2) return res.status(400).json({ error: '名号至少二字' });
-  if (!password || String(password).length < 4) return res.status(400).json({ error: '密语至少四位' });
-  const db = loadDb();
-  const existing = db.users.find(u => u.username === name);
-  if (existing) {
-    // 占位账号（自动建档、无密语）：升级须持有建档时发放的 claimToken，防任意抢占
-    if (!existing.passHash) {
-      const claimToken = String(req.body.claimToken || '');
-      if (!tokenMatches(existing, claimToken)) {
-        return res.status(409).json({ error: 'ACCOUNT_CLAIMED', message: '此名号已被自动建档占用，需持有建档凭据方可注册（或更换名号）' });
+  if (name.length > 24) return res.status(400).json({ error: '名号至多二十四字' });
+  if (!password || String(password).length < 8) return res.status(400).json({ error: '密语至少八位' });
+  const cleanProfile = sanitizeProfile(profile) || undefined;
+  // 锁内完成读-改-写：scrypt 为异步，若跨 await 会让并发注册互相覆盖（实测 30 并发仅 1 落库）
+  const outcome = await withUsersDb(async (db) => {
+    const users = (db as any).users as DbUser[];
+    const existing = users.find(u => u.username === name);
+    if (existing) {
+      // 占位账号（自动建档、无密语）：升级须持有建档时发放的 claimToken，防任意抢占
+      if (!existing.passHash) {
+        const claimToken = String(req.body.claimToken || '');
+        if (!tokenMatches(existing, claimToken)) {
+          return { status: 409, body: { error: 'ACCOUNT_CLAIMED', message: '此名号已被自动建档占用，需持有建档凭据方可注册（或更换名号）' } };
+        }
+        existing.passHash = await hashPassword(String(password));
+        existing.token = newToken();
+        existing.tokenExpires = Date.now() + TOKEN_TTL;
+        if (cleanProfile) existing.profile = { ...existing.profile, ...cleanProfile };
+        return { status: 200, body: { ok: true, upgraded: true, token: existing.token, user: { username: existing.username, profile: existing.profile, samples: existing.samples } } };
       }
-      existing.passHash = await hashPassword(String(password));
-      existing.token = newToken();
-      existing.tokenExpires = Date.now() + TOKEN_TTL;
-      if (profile) existing.profile = { ...existing.profile, ...profile };
-      saveDb(db);
-      return res.json({ ok: true, upgraded: true, token: existing.token, user: { username: existing.username, profile: existing.profile, samples: existing.samples } });
+      return { status: 400, body: { error: '此名号已有人用' } };
     }
-    return res.status(400).json({ error: '此名号已有人用' });
-  }
-  const user: DbUser = { username: name, passHash: await hashPassword(String(password)), createdAt: Date.now(), profile: profile || {}, samples: [], records: [], token: newToken(), tokenExpires: Date.now() + TOKEN_TTL };
-  db.users.push(user);
-  saveDb(db);
-  res.json({ ok: true, token: user.token, user: { username: user.username, profile: user.profile, samples: user.samples } });
+    const user: DbUser = { username: name, passHash: await hashPassword(String(password)), createdAt: Date.now(), profile: cleanProfile || {}, samples: [], records: [], token: newToken(), tokenExpires: Date.now() + TOKEN_TTL };
+    users.push(user);
+    return { status: 200, body: { ok: true, token: user.token, user: { username: user.username, profile: user.profile, samples: user.samples } } };
+  });
+  res.status(outcome.status).json(outcome.body);
 });
 
 // 登录
 router.post('/login', async (req, res) => {
   const { username, password } = req.body;
-  const db = loadDb();
-  const user = db.users.find(u => u.username === String(username || '').trim());
-  if (!user) return res.status(401).json({ error: '名号或密语未合' });
-  const ok = await verifyPassword(String(password || ''), user.passHash);
-  if (!ok) return res.status(401).json({ error: '名号或密语未合' });
-  // 旧哈希命中 → 升级为 scrypt 存储
-  if (user.passHash && !user.passHash.startsWith('scrypt$')) {
-    user.passHash = await hashPassword(String(password));
-    saveDb(db);
-    console.log(`[users] 密码哈希已升级为 scrypt: ${user.username}`);
-  }
-  // 登录成功 → 轮换 token（旧 token 即失效；防泄露长期有效）
-  user.token = newToken();
-  user.tokenExpires = Date.now() + TOKEN_TTL;
-  saveDb(db);
-  res.json({ ok: true, token: user.token, user: { username: user.username, profile: user.profile, samples: user.samples } });
+  const name = String(username || '').trim();
+  const outcome = await withUsersDb(async (db) => {
+    const users = (db as any).users as DbUser[];
+    const user = users.find(u => u.username === name);
+    // 名号不存在也走一次等价 scrypt，避免时序差异泄露账号是否存在（P2-2）
+    const ok = await verifyPassword(String(password || ''), user ? user.passHash : 'scrypt$' + '0'.repeat(32) + '$' + '0'.repeat(128));
+    if (!user || !ok) return { status: 401, body: { error: '名号或密语未合' } };
+    if (user.passHash && !user.passHash.startsWith('scrypt$')) {
+      user.passHash = await hashPassword(String(password));
+      console.log(`[users] 密码哈希已升级为 scrypt: ${user.username}`);
+    }
+    // 登录成功 → 轮换 token（旧 token 即失效）
+    user.token = newToken();
+    user.tokenExpires = Date.now() + TOKEN_TTL;
+    return { status: 200, body: { ok: true, token: user.token, user: { username: user.username, profile: user.profile, samples: user.samples } } };
+  });
+  res.status(outcome.status).json(outcome.body);
 });
 
 // ─── 写接口鉴权中间件：云同步写操作须携带本人 token（堵「知道 username 即可写任意档案」）───
@@ -170,7 +217,9 @@ router.put('/:username/profile', requireOwner, (req, res) => {
   const db = loadDb();
   const user = db.users.find(u => u.username === req.params.username);
   if (!user) return res.status(404).json({ error: '馆中无此人' });
-  user.profile = req.body.profile || user.profile;
+  const clean = sanitizeProfile(req.body.profile);
+  if (!clean) return res.status(400).json({ error: 'BAD_PROFILE', message: '档案格式不合法（字段白名单/长度/数值范围校验未通过）' });
+  user.profile = { ...user.profile, ...clean };
   saveDb(db);
   res.json({ ok: true, profile: user.profile });
 });
@@ -180,7 +229,7 @@ router.post('/:username/samples', requireOwner, (req, res) => {
   const db = loadDb();
   const user = db.users.find(u => u.username === req.params.username);
   if (!user) return res.status(404).json({ error: '馆中无此人' });
-  const sample = { id: 's' + Date.now(), name: String(req.body.name || '未名档案'), profile: req.body.profile || {} };
+  const sample = { id: 's' + Date.now(), name: String(req.body.name || '未名档案').slice(0, 40), profile: sanitizeProfile(req.body.profile) || {} };
   user.samples.push(sample);
   saveDb(db);
   res.json({ ok: true, samples: user.samples });
@@ -200,7 +249,9 @@ router.put('/:username/records', requireOwner, (req, res) => {
   const db = loadDb();
   const user = db.users.find(u => u.username === req.params.username);
   if (!user) return res.status(404).json({ error: '馆中无此人' });
-  user.records = Array.isArray(req.body.records) ? req.body.records : [];
+  const recs = sanitizeRecords(req.body.records);
+  if (!recs) return res.status(400).json({ error: 'BAD_RECORDS', message: '记录格式不合法（条数上限 2000 / 单条 20KB / 禁止危险键）' });
+  user.records = recs;
   saveDb(db);
   res.json({ ok: true, count: user.records.length });
 });

package/server/src/services/auth.ts

@@ -0,0 +1,53 @@
+// 鉴权统一入口：token → 用户（含过期校验）、请求来源判定
+//
+// 背景（2026-09 安全审查）：
+//  - 三处路由各自实现 authedUsername，口径漂移：ai.ts 漏校验 tokenExpires（过期 token 在 AI 链路永久可用）
+//  - 旧记录可能没有 tokenExpires 字段（1.3.3 前签发）→ 原逻辑视作「永不过期」；
+//    这些 token 已随 npm 1.3.2 包公开泄漏，故一律按失效处理（用户重新登录即可获新 token）
+import crypto from 'crypto';
+import { readUsersDb } from './usersDb.js';
+
+export interface TokenUser { username: string; user: any }
+
+/** 请求携带的 token → 用户（无 token / 不匹配 / 已过期 → null） */
+export function resolveTokenUser(req: any): TokenUser | null {
+  const tk = String(req.headers['x-guanwei-token'] || '');
+  if (!tk) return null;
+  try {
+    const db = readUsersDb();
+    const user = db.users.find((u: any) =>
+      u.token && u.token.length === tk.length && crypto.timingSafeEqual(Buffer.from(u.token), Buffer.from(tk)));
+    if (!user) return null;
+    // 过期即失效；无 tokenExpires 的旧记录（含已泄漏 token）同样视为失效
+    if (!user.tokenExpires || Date.now() > user.tokenExpires) return null;
+    return { username: user.username, user };
+  } catch { return null; }
+}
+
+/** 请求来源是否可信内网（回环 / RFC1918 / ULA）：匿名建档与占位账号放行仅限此类来源 */
+export function isTrustedOrigin(req: any): boolean {
+  const raw = String(req.ip || req.socket?.remoteAddress || '');
+  const ip = raw.replace(/^::ffff:/, '');
+  if (ip === '127.0.0.1' || ip === '::1') return true;
+  if (/^10\./.test(ip)) return true;
+  if (/^192\.168\./.test(ip)) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\./.test(ip)) return true;
+  if (/^f[cd][0-9a-f]{2}:/i.test(ip)) return true;   // fc00::/7
+  return false;
+}
+
+/** 显式放开匿名访问（公网部署且自担风险时设 GUANWEI_ALLOW_ANON=1） */
+export function anonAllowed(): boolean {
+  return process.env.GUANWEI_ALLOW_ANON === '1';
+}
+
+/** 强制所有匿名访问携带 token（公网部署更严；GUANWEI_REQUIRE_TOKEN=1） */
+export function requireTokenAlways(): boolean {
+  return process.env.GUANWEI_REQUIRE_TOKEN === '1';
+}
+
+/** 是否允许「无 token 的匿名操作」（建档/读占位账号） */
+export function allowAnonymous(req: any): boolean {
+  if (requireTokenAlways()) return false;
+  return anonAllowed() || isTrustedOrigin(req);
+}

package/server/src/services/chartBrief.ts

@@ -61,6 +61,16 @@ function ziweiBrief(r: ZiweiResult): string {
     palaceLines.push(PALACE_NAMES[i] + parts.join('｜'));
   }
   L.push('【十二宫事实（解读六亲/宫位必须逐字引用，不得推算或编造）】' + palaceLines.join('；') + '。');
+  // 昼夜与有效亮度（修正反馈：太阳喜昼、太阴喜夜——AI 论日月亮度须用有效值）
+  if (r.dayNight) L.push('【昼夜】' + (r.dayNight === 'day' ? '昼生（太阳得时、太阴减力）' : '夜生（太阴得时、太阳减力）') + '——论太阳/太阴亮度以【有效亮度】为准。');
+  if (r.effBrightness) L.push('【有效亮度（昼夜调整后）】' + Object.entries(r.effBrightness).map(([s, b]) => s + b).join('、') + '。');
+  // 空宫借对宫（修正反馈：空宫须借对宫看，勿论作真空）
+  if (r.borrowedStars) {
+    const PALACE2 = ['命', '兄弟', '夫妻', '子女', '财帛', '疾厄', '迁移', '交友', '官禄', '田宅', '福德', '父母'];
+    const bl = Object.entries(r.borrowedStars).filter(([, v]) => v.length > 0)
+      .map(([k, v]) => PALACE2[+k] + '宫空借对宫' + [...new Set(v)].join('、')).join('；');
+    if (bl) L.push('【空宫借星（空宫须借对宫主星论之，非真空）】' + bl + '。');
+  }
   if (r.geju?.length) L.push('【格局】' + r.geju.map(g => g.name + '(' + g.ji + ')').join('、') + '。');
   if (r.dayun?.length) L.push('【大限】当前第' + ((r.curDayunIdx ?? 0) + 1) + '大限（' + r.dayun[r.curDayunIdx ?? 0].start + '-' + r.dayun[r.curDayunIdx ?? 0].end + '岁，行至' + DIZHI[r.dayun[r.curDayunIdx ?? 0].palaceIdx] + '宫）。');
   L.push('【流年】' + (r.nominalAge ?? '') + '虚岁流年命宫落' + (r.liunianPalaceName || '') + '（' + DIZHI[r.liunianIdx ?? 0] + '），主星' + (r.liunianStars?.join('、') || '未临') + '。');

package/server/src/services/dataDir.ts

@@ -0,0 +1,80 @@
+// 运行时数据路径解析（用户档案 JSON / 占卜 SQLite / 测试库）
+//
+// 设计（2026-09 安全修复）：
+//  - 默认目录 **server/data/**（与 server/src 源码分离）——原 server/src/data 会被
+//    package.json 的 files 白名单（"server/src"）强制打进 npm tarball，导致用户档案
+//    （含 token/passHash/出生信息）与占卜记录随包公开（1.3.2 及更早版本已发生）。
+//  - 兼容旧路径：首次访问某文件时，若旧路径 server/src/data/<name> 存在且新路径不存在，
+//    自动复制一份（幂等，不删除旧文件，便于回滚）。
+//  - 环境变量优先：GUANWEI_DATA_DIR（目录）、GUANWEI_USERS_DB / GUANWEI_DB_FILE（单文件，测试隔离用）。
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * 运行时数据目录：默认 **用户主目录** `~/.guanwei/data`（可用 GUANWEI_DATA_DIR 覆盖）。
+ *
+ * 为什么放在项目目录之外（2026-09 事故后的硬门槛）：
+ * 原默认 server/src/data 在项目树内，npm 的 `files` 白名单一旦包含它就会被 publish 打包公开
+ * （1.1.1–1.3.2 全部版本因此泄漏用户档案与占卜记录）。移出项目树后，
+ * 即使白名单再次写错，npm/Docker 构建上下文也**物理上取不到**这些文件。
+ */
+/** 选择数据目录：env > 用户主目录（推荐）> 项目内 server/data（受限环境回退，仍受三重发布守卫保护） */
+function pickDataDir(): string {
+  const envDir = process.env.GUANWEI_DATA_DIR;
+  if (envDir) return envDir;
+  const home = path.join(os.homedir(), '.guanwei', 'data');
+  try {
+    fs.mkdirSync(home, { recursive: true });
+    fs.accessSync(home, fs.constants.W_OK);
+    return home;
+  } catch {
+    const fallback = path.join(__dirname, '..', '..', 'data');
+    console.warn('[data] 用户主目录不可写，回退到项目内目录: ' + fallback + '（发布守卫仍会阻止其进入 npm 包）');
+    return fallback;
+  }
+}
+
+export const DATA_DIR = pickDataDir();
+/** 兼容迁移源（按序尝试）：曾经使用过的项目内目录 */
+const LEGACY_DIRS = [
+  path.join(__dirname, '..', '..', 'data'),   // server/data（1.3.3 过渡路径）
+  path.join(__dirname, '..', 'data'),         // server/src/data（1.1.1–1.3.2 旧路径）
+];
+
+/** 解析数据文件路径（含旧目录一次性迁移） */
+export function dataFile(name: string): string {
+  const target = path.join(DATA_DIR, name);
+  try {
+    const legacy = LEGACY_DIRS.map(d => path.join(d, name)).find(p => fs.existsSync(p) && fs.statSync(p).size > 0);
+    const legacyOk = !!legacy;
+    const targetExists = fs.existsSync(target);
+    const targetSize = targetExists ? fs.statSync(target).size : 0;
+    let needFill = !targetExists || targetSize === 0;
+    // SQLite 库启发式：目标存在但显著小于旧库（如历史遗留的空壳库）→ 也迁移，避免真实记录被空库遮蔽
+    if (!needFill && /\.(db|sqlite|sqlite3)$/.test(name) && legacyOk && targetSize < fs.statSync(legacy!).size / 2) {
+      needFill = true;
+    }
+    if (legacyOk && needFill) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
+      if (targetExists && targetSize > 0) {
+        const bak = target + '.bak-' + Date.now();
+        fs.copyFileSync(target, bak);       // 覆盖前备份，可人工回滚
+        console.log('[data] 目标库较小，已备份: ' + bak);
+      }
+      fs.copyFileSync(legacy!, target);
+      console.log('[data] 已从旧路径迁移: ' + legacy + ' → ' + target + ' (' + fs.statSync(target).size + ' bytes)');
+    }
+  } catch (e: any) {
+    console.error('[data] 迁移失败（将按新路径处理）:', e?.message || e);
+  }
+  return target;
+}
+
+/** 用户档案库（JSON） */
+export const USERS_DB = process.env.GUANWEI_USERS_DB || dataFile('db.json');
+/** 占卜记录库（SQLite） */
+export const DIVINE_DB = process.env.GUANWEI_DB_FILE || dataFile('guanwei.db');

package/server/src/services/divineStore.ts

@@ -1,12 +1,14 @@
 // 占卜数据存储（SQLite）：起占记录 / AI 报告 / 失败留档 / 占卜历史
 // 依赖：node:sqlite（Node 22 内置，零依赖）
 import { DatabaseSync } from 'node:sqlite';
+import { DIVINE_DB } from './dataDir.js';
 import fs from 'fs';
+import { randomUUID } from 'node:crypto';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DB_FILE = process.env.GUANWEI_DB_FILE || path.join(__dirname, '..', 'data', 'guanwei.db');
+const DB_FILE = DIVINE_DB;
 
 let db: DatabaseSync | null = null;
 
@@ -104,7 +106,8 @@ function toRecord(row: any): DivineRecord {
 export function createDivination(args: CreateDivinationArgs): DivineRecord {
   const d = getDb();
   const now = Date.now();
-  const id = 'd_' + now + '_' + Math.random().toString(36).slice(2, 7);
+  // 原 Date.now()+Math.random() 可枚举（配合 403/404 差异可探测记录存在性）→ 改 CSPRNG UUID
+  const id = 'd_' + now + '_' + randomUUID();
   const display = args.display !== undefined ? args.display : args.resultRaw;
   d.prepare(`INSERT INTO divinations
     (id, username, art_id, kind, question, profile_id, profile_json, params_json, result_raw_json, display_json, status, created_at, updated_at)

package/server/src/services/duanyu.ts

@@ -11,9 +11,9 @@ function extractKeywords(artId: string, resultRaw: unknown): string[] {
     case 'bazi':
       // 月令/格局/用神/调候/旺衰
       if (r.monthZhi) kws.push('月令');
-      if (r.geju) kws.push('格局', String(r.geju));
-      if (r.yongshen) kws.push('用神', String(r.yongshen));
-      if (r.strength) kws.push(r.strength === '身强' ? '旺衰' : '旺衰');
+      if (r.geju) kws.push('格局', String(r.geju?.name || ''));            // geju 为对象，须取名（原 String(obj) 恒为 [object Object]）
+      if (r.yongshen) kws.push('用神', String(r.yongshen?.wx || r.yongshen?.shishen || ''));
+      if (r.strength) kws.push('旺衰', String(r.strength));                 // 原三元两分支同值（死代码）
       if (r.tiaohou) kws.push('调候');
       break;
     case 'liuyao':

package/server/src/services/llmProvider.ts

@@ -72,7 +72,7 @@ async function callOpenAI(cfg: ProviderConfig, messages: ChatMessage[], stream:
 
 async function callGoogle(cfg: ProviderConfig, messages: ChatMessage[], stream: boolean): Promise<Response> {
   const model = process.env[cfg.modelEnv || ''] || cfg.defaultModel;
-  const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${process.env[cfg.keyEnv]}`;
+  const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
   // 合并 messages 为 Google 格式：system → systemInstruction，其余 → contents
   const system = messages.filter(m => m.role === 'system').map(m => m.content).join('\n\n');
   const contents = messages.filter(m => m.role !== 'system').map(m => ({
@@ -81,7 +81,8 @@ async function callGoogle(cfg: ProviderConfig, messages: ChatMessage[], stream:
   }));
   return fetch(endpoint, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    // API Key 用 header 传递（原 ?key= 会进入 URL、代理日志与错误对象）
+    headers: { 'Content-Type': 'application/json', 'x-goog-api-key': String(process.env[cfg.keyEnv] || '') },
     body: JSON.stringify({
       systemInstruction: system ? { parts: [{ text: system }] } : undefined,
       contents,
@@ -99,7 +100,7 @@ async function withRetry<T>(fn: () => Promise<T>, label: string): Promise<T> {
       return await fn();
     } catch (e: any) {
       lastErr = e;
-      if (!/AI_HTTP_(429|5\d\d|400)/.test(e.message || '')) throw e;
+      if (!/AI_HTTP_(429|5\d\d)/.test(e.message || '')) throw e;   // 400 属请求体错误，重试必然再失败
       if (attempt < 2) {
         console.warn('[llm] ' + label + ' 第 ' + (attempt + 1) + ' 次失败(' + e.message + ')，重试…');
         await new Promise(r => setTimeout(r, 1500 * (attempt + 1)));

package/server/src/services/usersDb.ts

@@ -0,0 +1,45 @@
+// 用户库（JSON）读写：进程内串行锁 + 原子写
+//
+// 背景（2026-09 并发写缺陷）：原 users.ts/divine.ts 各自 read-modify-write 整份 db.json，
+// 且 load→改→save 之间跨 await（scrypt 哈希），并发请求互相覆盖——实测 30 个并发注册仅 1 个落库。
+// 现统一走本模块：单进程内以 Promise 链串行化写操作，落盘用 临时文件 + rename 原子替换。
+import fs from 'fs';
+import path from 'path';
+import { USERS_DB } from './dataDir.js';
+
+export interface UsersDb { users: any[] }
+
+/** 读用户库（文件缺失/损坏 → 空库，交由调用方建档） */
+export function readUsersDb(): UsersDb {
+  try { return JSON.parse(fs.readFileSync(USERS_DB, 'utf-8')); }
+  catch { return { users: [] }; }
+}
+
+/** 原子写：先写同目录临时文件再 rename，避免半截文件与并发撕裂 */
+export function writeUsersDb(db: UsersDb): void {
+  fs.mkdirSync(path.dirname(USERS_DB), { recursive: true });
+  const tmp = USERS_DB + '.tmp-' + process.pid + '-' + Date.now();
+  fs.writeFileSync(tmp, JSON.stringify(db, null, 2));
+  fs.renameSync(tmp, USERS_DB);
+}
+
+// 写串行队列（单进程内生效；多进程部署需外部锁，见 README 部署说明）
+let chain: Promise<unknown> = Promise.resolve();
+
+/** 串行执行一次「读-改-写」事务；fn 内可安全 await（如 scrypt） */
+export function withUsersDb<T>(fn: (db: UsersDb) => T | Promise<T>): Promise<T> {
+  const run = chain.then(() => {
+    const db = readUsersDb();
+    return Promise.resolve(fn(db)).then((result) => {
+      writeUsersDb(db);   // fn 内直接改 db 对象即可；由本函数统一落盘
+      return result;
+    });
+  });
+  chain = run.catch(() => { /* 防止链断 */ });
+  return run as Promise<T>;
+}
+
+/** 只读事务（不落盘） */
+export function readUsers<T>(fn: (db: UsersDb) => T): T {
+  return fn(readUsersDb());
+}

package/shared/core/data/gua64.ts

@@ -21,11 +21,11 @@ const RAW: [number, number, string, string, string][] = [
   [1, 1, '乾为天', '元亨利贞。天行健，君子以自强不息。', '刚健中正，自强之象'],
   [8, 8, '坤为地', '元亨，利牝马之贞。地势坤，君子以厚德载物。', '柔顺包容，厚德之象'],
   [6, 4, '水雷屯', '元亨利贞，勿用有攸往，利建侯。', '始生维艰，草创之象'],
-  [7, 6, '山水蒙', '亨。匪我求童蒙，童蒙求我。', '蒙昧待启，求教之象'],
+  [7, 6, '山水蒙', '亨。匪我求童蒙，童蒙求我。初筮告，再三渎，渎则不告。利贞。', '蒙昧待启，求教之象'],
   [6, 1, '水天需', '有孚，光亨，贞吉，利涉大川。', '云上于天，待时之象'],
   [1, 6, '天水讼', '有孚窒惕，中吉，终凶。利见大人，不利涉大川。', '争讼之象，和为贵'],
-  [6, 8, '地水师', '贞，丈人吉，无咎。', '行险而顺，统众之象'],
-  [8, 6, '水地比', '吉。原筮，元永贞，无咎。', '亲附之象，众心所归'],
+  [8, 6, '地水师', '贞，丈人吉，无咎。', '行险而顺，统众之象'],
+  [6, 8, '水地比', '吉。原筮，元永贞，无咎。不宁方来，后夫凶。', '亲附之象，众心所归'],
   [5, 1, '风天小畜', '亨。密云不雨，自我西郊。', '小有蓄积，待时而动'],
   [1, 2, '天泽履', '履虎尾，不咥人，亨。', '谨慎履险，如履薄冰'],
   [8, 1, '地天泰', '小往大来，吉亨。天地交而万物通。', '通泰之象，上下交心'],
@@ -41,7 +41,7 @@ const RAW: [number, number, string, string, string][] = [
   [3, 4, '火雷噬嗑', '亨。利用狱。雷电合而章。', '咬合之象，明罚敕法'],
   [7, 3, '山火贲', '亨。小利有攸往。', '文饰之象，饰外修内'],
   [7, 8, '山地剥', '不利有攸往。顺而止之。', '剥落之象，顺势而止'],
-  [8, 4, '地雷复', '亨。出入无疾，朋来无咎。', '复归之象，一阳来复'],
+  [8, 4, '地雷复', '亨。出入无疾，朋来无咎。反复其道，七日来复，利有攸往。', '复归之象，一阳来复'],
   [1, 4, '天雷无妄', '元亨利贞。其匪正有眚，不利有攸往。', '无妄之象，守正勿妄'],
   [7, 1, '山天大畜', '利贞。不家食吉，利涉大川。', '大蓄之象，厚积薄发'],
   [7, 4, '山雷颐', '贞吉。观颐，自求口实。', '颐养之象，自养养人'],
@@ -57,7 +57,7 @@ const RAW: [number, number, string, string, string][] = [
   [5, 3, '风火家人', '利女贞。', '一家之象，各正其位'],
   [3, 2, '火泽睽', '小事吉。二女同居，其志不同行。', '乖离之象，求同存异'],
   [6, 7, '水山蹇', '利西南，不利东北。利见大人，贞吉。', '艰难之象，见险知止'],
-  [4, 6, '雷水解', '利西南。无所往，其来复吉。', '解除之象，雷雨作而百果生'],
+  [4, 6, '雷水解', '利西南。无所往，其来复吉。有攸往，夙吉。', '解除之象，雷雨作而百果生'],
   [7, 2, '山泽损', '有孚，元吉，无咎，可贞，利有攸往。', '减损之象，损下益上'],
   [5, 4, '风雷益', '利有攸往，利涉大川。', '增益之象，损上益下'],
   [2, 1, '泽天夬', '扬于王庭，孚号有厉。告自邑，不利即戎。', '决断之象，刚决柔也'],

package/shared/core/data/qimen.ts

@@ -6,16 +6,18 @@ export const QM_STARS = ['天蓬', '天芮', '天冲', '天辅', '天禽', '天
 export const QM_SHEN = ['值符', '腾蛇', '太阴', '六合', '白虎', '玄武', '九地', '九天'];
 export const QM_QIYI = ['戊', '己', '庚', '辛', '壬', '癸', '丁', '丙', '乙'];
 
-// 节气 → 阴阳遁局数（简表：按节令三分）
+// 节气 → 阴阳遁局数（上/中/下三元，权威口径，对照 qimen-dunjia《遁甲演義/寶鑒御定》局表）
+// 阳遁：冬至~芒种（12 节）；阴遁：夏至~大雪。春分~芒种仍阳遁（勿误作阴）。
+// 2026-09 修正：原表春分起误标阴遁且局数系统性错误
 export const QM_SEASONS: { name: string; yin: boolean; ju: number[] }[] = [
-  { name: '冬至', yin: false, ju: [1, 2, 3] }, { name: '小寒', yin: false, ju: [2, 3, 4] }, { name: '大寒', yin: false, ju: [3, 4, 5] },
-  { name: '立春', yin: false, ju: [8, 9, 1] }, { name: '雨水', yin: false, ju: [9, 1, 2] }, { name: '惊蛰', yin: false, ju: [1, 2, 3] },
-  { name: '春分', yin: true, ju: [3, 2, 1] }, { name: '清明', yin: true, ju: [4, 3, 2] }, { name: '谷雨', yin: true, ju: [5, 4, 3] },
-  { name: '立夏', yin: true, ju: [4, 3, 2] }, { name: '小满', yin: true, ju: [5, 4, 3] }, { name: '芒种', yin: true, ju: [6, 5, 4] },
-  { name: '夏至', yin: true, ju: [9, 8, 7] }, { name: '小暑', yin: true, ju: [8, 7, 6] }, { name: '大暑', yin: true, ju: [7, 6, 5] },
-  { name: '立秋', yin: true, ju: [2, 1, 9] }, { name: '处暑', yin: true, ju: [1, 9, 8] }, { name: '白露', yin: true, ju: [9, 8, 7] },
-  { name: '秋分', yin: true, ju: [7, 8, 9] }, { name: '寒露', yin: true, ju: [6, 7, 8] }, { name: '霜降', yin: true, ju: [5, 6, 7] },
-  { name: '立冬', yin: true, ju: [6, 7, 8] }, { name: '小雪', yin: true, ju: [5, 6, 7] }, { name: '大雪', yin: true, ju: [4, 5, 6] },
+  { name: '冬至', yin: false, ju: [1, 7, 4] }, { name: '小寒', yin: false, ju: [2, 8, 5] }, { name: '大寒', yin: false, ju: [3, 9, 6] },
+  { name: '立春', yin: false, ju: [8, 5, 2] }, { name: '雨水', yin: false, ju: [9, 6, 3] }, { name: '惊蛰', yin: false, ju: [1, 7, 4] },
+  { name: '春分', yin: false, ju: [3, 9, 6] }, { name: '清明', yin: false, ju: [4, 1, 7] }, { name: '谷雨', yin: false, ju: [5, 2, 8] },
+  { name: '立夏', yin: false, ju: [4, 1, 7] }, { name: '小满', yin: false, ju: [5, 2, 8] }, { name: '芒种', yin: false, ju: [6, 3, 9] },
+  { name: '夏至', yin: true, ju: [9, 3, 6] }, { name: '小暑', yin: true, ju: [8, 2, 5] }, { name: '大暑', yin: true, ju: [7, 1, 4] },
+  { name: '立秋', yin: true, ju: [2, 5, 8] }, { name: '处暑', yin: true, ju: [1, 4, 7] }, { name: '白露', yin: true, ju: [9, 3, 6] },
+  { name: '秋分', yin: true, ju: [7, 1, 4] }, { name: '寒露', yin: true, ju: [6, 9, 3] }, { name: '霜降', yin: true, ju: [5, 8, 2] },
+  { name: '立冬', yin: true, ju: [6, 9, 3] }, { name: '小雪', yin: true, ju: [5, 8, 2] }, { name: '大雪', yin: true, ju: [4, 7, 1] },
 ];
 
 // 节气近似日期（公历，演示级排盘与奇门定遁用）