guanwei 1.3.2 → 1.3.5

package/server/src/services/auth.ts

@@ -0,0 +1,50 @@
+// 鉴权统一入口：token → 用户（含过期校验）、请求来源判定
+//
+// 背景（2026-09 安全审查）：
+//  - 三处路由各自实现 authedUsername，口径漂移：ai.ts 漏校验 tokenExpires（过期 token 在 AI 链路永久可用）
+//  - 旧记录可能没有 tokenExpires 字段（1.3.3 前签发）→ 原逻辑视作「永不过期」；
+//    这些 token 已随 npm 1.3.2 包公开泄漏，故一律按失效处理（用户重新登录即可获新 token）
+import { getUserByToken, type UserRow } from './usersStore.js';
+
+export interface TokenUser { username: string; user: UserRow }
+
+/** 请求携带的 token → 用户（无 token / 不匹配 / 已过期 → null） */
+export function resolveTokenUser(req: any): TokenUser | null {
+  const tk = String(req.headers['x-guanwei-token'] || '');
+  if (!tk) return null;
+  try {
+    const user = getUserByToken(tk);   // 存储：统一 SQLite（含恒时比较）
+    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/dataDir.ts

@@ -0,0 +1,95 @@
+// 运行时数据路径解析（用户档案 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);
+  // SQLite WAL 模式下数据可能主要落在 -wal 文件里、主库文件本身很小；
+  // 比较体积时必须把 -wal/-shm 计入，否则会误判「目标库较小」而用旧库覆盖新库。
+  const sizeOf = (p: string): number => {
+    try {
+      let n = fs.statSync(p).size;
+      for (const suffix of ['-wal', '-shm']) {
+        try { n += fs.statSync(p + suffix).size; } catch { /* 无副文件 */ }
+      }
+      return n;
+    } catch { return 0; }
+  };
+  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 = sizeOf(target);
+    let needFill = !targetExists || targetSize === 0;
+    // SQLite 库启发式：目标存在但显著小于旧库（如历史遗留的空壳库）→ 也迁移，避免真实记录被空库遮蔽
+    if (!needFill && /\.(db|sqlite|sqlite3)$/.test(name) && legacyOk && targetSize < sizeOf(legacy!) / 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);
+      // 只复制主库：旧库的 WAL 副文件若一并留用会与新主库不匹配
+      for (const suffix of ['-wal', '-shm']) {
+        try { fs.rmSync(target + suffix, { force: true }); } catch { /* ignore */ }
+      }
+      console.log('[data] 已从旧路径迁移: ' + legacy + ' → ' + target + ' (' + fs.statSync(target).size + ' bytes)');
+    }
+  } catch (e: any) {
+    console.error('[data] 迁移失败（将按新路径处理）:', e?.message || e);
+  }
+  return target;
+}
+
+/** 旧用户档案库（JSON）：仅作一次性导入来源（见 services/usersStore.ensureInit） */
+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/db.ts

@@ -0,0 +1,131 @@
+// 统一 SQLite 句柄（单一数据源）
+//
+// 背景（2026-09 W38 架构欠债 #4）：用户库曾是 JSON（db.json）、占卜记录是 SQLite（guanwei.db），
+// 两套存储两套写法：JSON 侧靠「进程内 Promise 串行 + 临时文件 rename」，SQLite 侧靠事务。
+// 现合并为**同一个 SQLite 库**：users / divinations / ai_fail_logs / meta 四张表，
+// 所有写操作走 BEGIN IMMEDIATE 事务，跨进程亦安全（busy_timeout + WAL）。
+//
+// 依赖：node:sqlite（Node 22 内置，零依赖）
+import { createRequire } from 'node:module';
+import { DIVINE_DB } from './dataDir.js';
+import fs from 'fs';
+import path from 'path';
+
+// node:sqlite 用 createRequire 运行时加载：
+//  - 前端测试（vitest/jsdom）会沿 import 链把 server 模块也走 Vite 打包，静态 import 会被判为
+//    「Cannot bundle built-in module "node:sqlite"」；require 形式可避免。运行时行为完全一致。
+//  - 顺带让「仅导入而不使用存储」的场景不加载 SQLite。
+type DatabaseSync = import('node:sqlite').DatabaseSync;
+type DatabaseSyncCtor = typeof import('node:sqlite').DatabaseSync;
+
+let DatabaseSyncImpl: DatabaseSyncCtor | null = null;
+function sqlite(): DatabaseSyncCtor {
+  if (!DatabaseSyncImpl) {
+    DatabaseSyncImpl = createRequire(import.meta.url)('node:sqlite').DatabaseSync as DatabaseSyncCtor;
+  }
+  return DatabaseSyncImpl;
+}
+
+let db: DatabaseSync | null = null;
+
+/** 取库句柄（首次调用建表 + 迁移） */
+export function getDb(): DatabaseSync {
+  if (db) return db;
+  fs.mkdirSync(path.dirname(DIVINE_DB), { recursive: true });
+  db = new (sqlite())(DIVINE_DB);
+  // WAL：读写不互斥（外部工具/测试可同时只读）；busy_timeout：多进程时等待而非立刻 SQLITE_BUSY
+  try { db.exec('PRAGMA journal_mode = WAL'); } catch (e: any) { console.warn('[db] WAL 未启用:', e?.message || e); }
+  try { db.exec('PRAGMA busy_timeout = 5000'); } catch { /* 老版本忽略 */ }
+  try { db.exec('PRAGMA foreign_keys = ON'); } catch { /* 同上 */ }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      username      TEXT PRIMARY KEY,
+      pass_hash     TEXT NOT NULL DEFAULT '',
+      created_at    INTEGER NOT NULL,
+      profile_json  TEXT NOT NULL DEFAULT '{}',
+      samples_json  TEXT NOT NULL DEFAULT '[]',
+      records_json  TEXT NOT NULL DEFAULT '[]',
+      token         TEXT,
+      token_expires INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_users_token ON users(token);
+
+    CREATE TABLE IF NOT EXISTS divinations (
+      id            TEXT PRIMARY KEY,
+      username      TEXT NOT NULL,
+      art_id        TEXT NOT NULL,
+      kind          TEXT NOT NULL,
+      question      TEXT,
+      profile_id    TEXT NOT NULL DEFAULT 'main',
+      profile_json  TEXT,
+      params_json   TEXT,
+      result_raw_json TEXT NOT NULL,
+      display_json  TEXT NOT NULL,
+      report_json   TEXT,
+      report_quality TEXT,
+      status        TEXT NOT NULL DEFAULT 'divined',
+      created_at    INTEGER NOT NULL,
+      updated_at    INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_div_user_time ON divinations(username, created_at DESC);
+
+    CREATE TABLE IF NOT EXISTS ai_fail_logs (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      art_id      TEXT NOT NULL,
+      kind        TEXT NOT NULL,
+      divine_id   TEXT,
+      raw_output  TEXT,
+      fail_reason TEXT,
+      created_at  INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS meta (
+      k TEXT PRIMARY KEY,
+      v TEXT NOT NULL
+    );
+  `);
+  // 老库迁移：补 divinations.profile_id 列（2026-08-20 档案隔离）——必须在引用该列的索引之前
+  try {
+    db.exec("ALTER TABLE divinations ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'main'");
+  } catch (e: any) {
+    if (!/duplicate column/i.test(e.message || '')) console.error('[db] 迁移 profile_id 失败:', e.message);
+  }
+  db.exec('CREATE INDEX IF NOT EXISTS idx_div_user_profile ON divinations(username, profile_id, created_at DESC)');
+  return db;
+}
+
+/**
+ * 立即写事务：fn 内**不得 await**（node:sqlite 为同步 API）。
+ * BEGIN IMMEDIATE 立刻取写锁，避免「读后写」之间的竞态（并发注册/建档的唯一性由此保证）。
+ */
+export function withTx<T>(fn: () => T): T {
+  const d = getDb();
+  d.exec('BEGIN IMMEDIATE');
+  try {
+    const result = fn();
+    d.exec('COMMIT');
+    return result;
+  } catch (e) {
+    try { d.exec('ROLLBACK'); } catch { /* 回滚失败时以原异常为准 */ }
+    throw e;
+  }
+}
+
+/** 读取元信息（迁移标记等） */
+export function getMeta(k: string): string | null {
+  try {
+    const row = getDb().prepare('SELECT v FROM meta WHERE k = ?').get(k) as { v?: string } | undefined;
+    return row?.v ?? null;
+  } catch { return null; }
+}
+
+/** 写入元信息 */
+export function setMeta(k: string, v: string): void {
+  getDb().prepare('INSERT INTO meta (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v').run(k, v);
+}
+
+/** 仅测试/运维用：关闭句柄（下次调用重新打开） */
+export function closeDb(): void {
+  try { db?.close(); } catch { /* ignore */ }
+  db = null;
+}

package/server/src/services/divineStore.ts

@@ -1,58 +1,10 @@
 // 占卜数据存储（SQLite）：起占记录 / AI 报告 / 失败留档 / 占卜历史
-// 依赖：node:sqlite（Node 22 内置，零依赖）
-import { DatabaseSync } from 'node:sqlite';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+// 句柄与建表统一由 services/db 提供（与用户库同库，见 db.ts）
+import { getDb, withTx } from './db.js';
+import { randomUUID } from 'node:crypto';
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const DB_FILE = process.env.GUANWEI_DB_FILE || path.join(__dirname, '..', 'data', 'guanwei.db');
-
-let db: DatabaseSync | null = null;
-
-export function getDb(): DatabaseSync {
-  if (db) return db;
-  fs.mkdirSync(path.dirname(DB_FILE), { recursive: true });
-  db = new DatabaseSync(DB_FILE);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS divinations (
-      id            TEXT PRIMARY KEY,
-      username      TEXT NOT NULL,
-      art_id        TEXT NOT NULL,
-      kind          TEXT NOT NULL,
-      question      TEXT,
-      profile_id    TEXT NOT NULL DEFAULT 'main',
-      profile_json  TEXT,
-      params_json   TEXT,
-      result_raw_json TEXT NOT NULL,
-      display_json  TEXT NOT NULL,
-      report_json   TEXT,
-      report_quality TEXT,
-      status        TEXT NOT NULL DEFAULT 'divined',
-      created_at    INTEGER NOT NULL,
-      updated_at    INTEGER NOT NULL
-    );
-    CREATE INDEX IF NOT EXISTS idx_div_user_time ON divinations(username, created_at DESC);
-
-    CREATE TABLE IF NOT EXISTS ai_fail_logs (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      art_id      TEXT NOT NULL,
-      kind        TEXT NOT NULL,
-      divine_id   TEXT,
-      raw_output  TEXT,
-      fail_reason TEXT,
-      created_at  INTEGER NOT NULL
-    );
-  `);
-  // 老库迁移：补 profile_id 列（2026-08-20 档案隔离）——必须在引用该列的索引之前
-  try {
-    db.exec("ALTER TABLE divinations ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'main'");
-  } catch (e: any) {
-    if (!/duplicate column/i.test(e.message || '')) console.error('[divineStore] 迁移 profile_id 失败:', e.message);
-  }
-  db.exec('CREATE INDEX IF NOT EXISTS idx_div_user_profile ON divinations(username, profile_id, created_at DESC)');
-  return db;
-}
+export { getDb };
+export { withTx };
 
 export interface DivineRecord {
   id: string;
@@ -104,7 +56,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)
@@ -153,6 +106,7 @@ export function markAiFailed(id: string | null, artId: string, kind: string, rea
 }
 
 // 占卜历史分页（时间倒序，摘要字段）
+// 同一毫秒内建立的记录（如冒烟/并发场景）以 rowid 兜底，保证分页顺序确定（原按 id 比较 uuid，顺序随机）
 export function listDivinations(username: string, page = 1, pageSize = 20, profileId?: string): { list: { divineId: string; artId: string; question: string | null; createdAt: number; hasReport: boolean; status: string; profileId: string }[]; total: number } {
   const d = getDb();
   const pageN = Math.max(1, page);
@@ -160,7 +114,7 @@ export function listDivinations(username: string, page = 1, pageSize = 20, profi
   const where = profileId ? 'WHERE username = ? AND profile_id = ?' : 'WHERE username = ?';
   const params = profileId ? [username, profileId] : [username];
   const totalRow = d.prepare('SELECT COUNT(*) AS c FROM divinations ' + where).get(...params) as any;
-  const rows = d.prepare('SELECT id, art_id, question, created_at, report_json, status, profile_id FROM divinations ' + where + ' ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?')
+  const rows = d.prepare('SELECT id, art_id, question, created_at, report_json, status, profile_id FROM divinations ' + where + ' ORDER BY created_at DESC, rowid DESC LIMIT ? OFFSET ?')
     .all(...params, size, (pageN - 1) * size) as any[];
   return {
     list: rows.map(r => ({

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/usersStore.ts

@@ -0,0 +1,221 @@
+// 用户库（SQLite）：账号 / 出生档案 / 示例档案 / 云同步记录 / 登录态 token
+//
+// 历史（2026-09）：原为 JSON 文件（db.json）+ 进程内 Promise 串行锁。合并到统一 SQLite 后：
+//  - 写操作走 BEGIN IMMEDIATE 事务：并发注册/建档不再互相覆盖，也不再依赖进程内锁
+//  - 与占卜记录同库：跨进程一致（WAL + busy_timeout），外部工具可只读查看
+//  - 旧 db.json 在 users 表为空时**一次性导入**（原文件保留，不删除，便于回滚）
+import crypto from 'crypto';
+import fs from 'fs';
+import { getDb, withTx, getMeta, setMeta } from './db.js';
+import { USERS_DB } from './dataDir.js';
+
+export interface Sample { id: string; name: string; profile: Record<string, unknown> }
+export interface UserRow {
+  username: string;
+  passHash: string;
+  createdAt: number;
+  profile: Record<string, unknown>;
+  samples: Sample[];
+  records: Record<string, unknown>[];
+  /** 登录态 token（注册/登录签发）；占位账号为建档凭据 claimToken */
+  token?: string;
+  tokenExpires?: number;
+}
+
+const COLS = 'username, pass_hash, created_at, profile_json, samples_json, records_json, token, token_expires';
+
+function parseJson<T>(s: unknown, fallback: T): T {
+  if (typeof s !== 'string' || !s) return fallback;
+  try {
+    const v = JSON.parse(s);
+    return (v ?? fallback) as T;
+  } catch { return fallback; }
+}
+
+function rowToUser(r: any): UserRow {
+  return {
+    username: String(r.username),
+    passHash: String(r.pass_hash || ''),
+    createdAt: Number(r.created_at || 0),
+    profile: parseJson<Record<string, unknown>>(r.profile_json, {}),
+    samples: parseJson<Sample[]>(r.samples_json, []),
+    records: parseJson<Record<string, unknown>[]>(r.records_json, []),
+    token: r.token ? String(r.token) : undefined,
+    tokenExpires: r.token_expires == null ? undefined : Number(r.token_expires),
+  };
+}
+
+// ─── token 工具（原 users.ts 逻辑，统一到此处，供 routes/auth 复用）───
+export function newToken(): string {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+/** 恒时比较 token（含过期校验）：false = 无效 */
+export function tokenMatches(user: Pick<UserRow, 'token' | 'tokenExpires'> | null | undefined, token: string | undefined): boolean {
+  if (!user || !token || !user.token) return false;
+  if (user.tokenExpires && Date.now() > user.tokenExpires) return false;   // 过期即失效
+  const a = Buffer.from(token), b = Buffer.from(user.token);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+// ─── 读 ───
+export function getUser(username: string): UserRow | null {
+  ensureInit();
+  if (!username) return null;
+  const row = getDb().prepare(`SELECT ${COLS} FROM users WHERE username = ?`).get(username) as any;
+  return row ? rowToUser(row) : null;
+}
+
+export function userCount(): number {
+  ensureInit();
+  return Number((getDb().prepare('SELECT COUNT(*) AS c FROM users').get() as any)?.c || 0);
+}
+
+/** token → 用户（仅返回 token 完全匹配者；不匹配/不存在 → null） */
+export function getUserByToken(token: string): UserRow | null {
+  ensureInit();
+  if (!token) return null;
+  const row = getDb().prepare(`SELECT ${COLS} FROM users WHERE token = ?`).get(token) as any;
+  if (!row) return null;
+  const user = rowToUser(row);
+  // 索引命中后再做一次恒时比较（防御性：避免长度差异等边信道）
+  return tokenMatches(user, token) ? user : null;
+}
+
+// ─── 写 ───
+export interface NewUser {
+  username: string; passHash?: string; profile?: Record<string, unknown>;
+  token?: string; tokenExpires?: number;
+}
+
+/** 新建账号（已存在 → false，不覆盖）；占位账号亦经此建（passHash 为空串） */
+export function createUserIfAbsent(u: NewUser): boolean {
+  ensureInit();
+  const res = getDb().prepare(
+    'INSERT OR IGNORE INTO users (username, pass_hash, created_at, profile_json, samples_json, records_json, token, token_expires) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
+  ).run(
+    u.username, u.passHash ?? '', Date.now(),
+    JSON.stringify(u.profile ?? {}), '[]', '[]',
+    u.token ?? null, u.tokenExpires ?? null,
+  );
+  return Number(res.changes || 0) > 0;
+}
+
+/** 占位账号升级为正式账号：写入密语哈希 + 轮换 token（须在事务内调用） */
+export function upgradePlaceholder(username: string, passHash: string, token: string, tokenExpires: number, profilePatch?: Record<string, unknown>): void {
+  const merged = profilePatch ? { ...(getUser(username)?.profile || {}), ...profilePatch } : null;
+  getDb().prepare('UPDATE users SET pass_hash = ?, token = ?, token_expires = ? WHERE username = ?')
+    .run(passHash, token, tokenExpires, username);
+  if (merged) setProfileJson(username, merged);
+}
+
+/** 轮换 token（登录成功时） */
+export function rotateToken(username: string, token: string, tokenExpires: number): void {
+  getDb().prepare('UPDATE users SET token = ?, token_expires = ? WHERE username = ?').run(token, tokenExpires, username);
+}
+
+/** 升级密语哈希（旧格式登录命中时） */
+export function setPassHash(username: string, passHash: string): void {
+  getDb().prepare('UPDATE users SET pass_hash = ? WHERE username = ?').run(passHash, username);
+}
+
+function setProfileJson(username: string, profile: Record<string, unknown>): void {
+  getDb().prepare('UPDATE users SET profile_json = ? WHERE username = ?').run(JSON.stringify(profile), username);
+}
+
+/** 档案合并写（浅合并）；返回新档案，用户不存在 → null */
+export function mergeProfile(username: string, patch: Record<string, unknown>): Record<string, unknown> | null {
+  ensureInit();
+  return withTx(() => {
+    const u = getUser(username);
+    if (!u) return null;
+    const merged = { ...u.profile, ...patch };
+    setProfileJson(username, merged);
+    return merged;
+  });
+}
+
+/** 示例档案：追加 */
+export function addSample(username: string, sample: Sample): Sample[] | null {
+  ensureInit();
+  return withTx(() => {
+    const u = getUser(username);
+    if (!u) return null;
+    const samples = [...u.samples, sample];
+    getDb().prepare('UPDATE users SET samples_json = ? WHERE username = ?').run(JSON.stringify(samples), username);
+    return samples;
+  });
+}
+
+/** 示例档案：删除 */
+export function removeSample(username: string, id: string): Sample[] | null {
+  ensureInit();
+  return withTx(() => {
+    const u = getUser(username);
+    if (!u) return null;
+    const samples = u.samples.filter(s => s.id !== id);
+    getDb().prepare('UPDATE users SET samples_json = ? WHERE username = ?').run(JSON.stringify(samples), username);
+    return samples;
+  });
+}
+
+/** 云同步记录：整表覆盖 */
+export function setRecords(username: string, records: Record<string, unknown>[]): number | null {
+  ensureInit();
+  return withTx(() => {
+    const u = getUser(username);
+    if (!u) return null;
+    getDb().prepare('UPDATE users SET records_json = ? WHERE username = ?').run(JSON.stringify(records), username);
+    return records.length;
+  });
+}
+
+// ─── 旧 JSON 库一次性导入 ───
+const IMPORT_MARK = 'users_imported_from_json';
+let inited = false;
+
+/** 幂等初始化：users 表为空且存在旧 db.json → 导入（原文件保留） */
+export function ensureInit(): void {
+  if (inited) return;
+  inited = true;
+  try {
+    const imported = getMeta(IMPORT_MARK);
+    if (imported) return;                       // 本库已导入过
+    if (userCountRaw() > 0) { setMeta(IMPORT_MARK, 'skip:users-exist'); return; }
+    let raw: string;
+    try { raw = fs.readFileSync(USERS_DB, 'utf-8'); } catch { return; }   // 无旧库：全新安装
+    const parsed = JSON.parse(raw);
+    const users: any[] = Array.isArray(parsed?.users) ? parsed.users : [];
+    if (!users.length) { setMeta(IMPORT_MARK, 'skip:json-empty'); return; }
+    let n = 0;
+    withTx(() => {
+      for (const u of users) {
+        if (!u || typeof u.username !== 'string' || !u.username) continue;
+        const ok = insertLegacy(u);
+        if (ok) n++;
+      }
+      setMeta(IMPORT_MARK, `imported:${n}:${USERS_DB}`);
+    });
+    console.log(`[usersStore] 已从旧 JSON 库导入 ${n} 个账号: ${USERS_DB}`);
+  } catch (e: any) {
+    console.error('[usersStore] 旧 JSON 库导入失败（跳过，不影响新库）:', e?.message || e);
+  }
+}
+
+function userCountRaw(): number {
+  return Number((getDb().prepare('SELECT COUNT(*) AS c FROM users').get() as any)?.c || 0);
+}
+
+function insertLegacy(u: any): boolean {
+  const res = getDb().prepare(
+    'INSERT OR IGNORE INTO users (username, pass_hash, created_at, profile_json, samples_json, records_json, token, token_expires) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
+  ).run(
+    String(u.username), String(u.passHash || ''), Number(u.createdAt || Date.now()),
+    JSON.stringify(u.profile && typeof u.profile === 'object' ? u.profile : {}),
+    JSON.stringify(Array.isArray(u.samples) ? u.samples : []),
+    JSON.stringify(Array.isArray(u.records) ? u.records : []),
+    u.token ? String(u.token) : null,
+    u.tokenExpires == null ? null : Number(u.tokenExpires),
+  );
+  return Number(res.changes || 0) > 0;
+}

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, '泽天夬', '扬于王庭，孚号有厉。告自邑，不利即戎。', '决断之象，刚决柔也'],