@allbluecn/web-app 0.23.1 → 0.23.3

package/src/server/__tests__/exchange-remote-token.test.ts

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+
+// exchangeRemoteTokenFn 双路径落盘测试（A10 修复，控制者核实缺口）：
+// session 块（remote-auth.json 的 session.userId/planName，readRemoteAuth 登录态
+// 唯一依据）必须两条成功路径都写——原先仅降级路径写，生产 SaaS 恒发 signedToken
+// → signedToken 路径云身份 100% 不激活 + 云态写入属主错为 guest。
+// mock 惯例照 desktop-bootstrap.test.ts（csv-export 样板）：createServerFn 捕获器
+// 直调 handler；SaaS fetch 用 vi.stubGlobal 拦截，remote-auth/entitlements-token
+// /rate-limit 全 mock（不真写盘、不真限流）。
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const H = vi.hoisted(() => ({
+  writeRemoteAuth: vi.fn(),
+  writeRemoteSession: vi.fn(),
+  generateEntitlementsToken: vi.fn(),
+  checkAuthRateLimit: vi.fn(),
+  fetch: vi.fn(),
+}))
+
+vi.mock('@tanstack/react-start', () => {
+  // 每个 serverFn 实例独立 capture（session.ts 有三个 serverFn，防串号）
+  const createServerFn = () => {
+    const capture: { validator?: unknown; handler?: unknown } = {}
+    const api = {
+      validator: (v: unknown) => {
+        capture.validator = v
+        return api
+      },
+      middleware: () => api,
+      handler: (h: unknown) => {
+        capture.handler = h
+        return async (args?: { data?: unknown }) => {
+          const v = capture.validator as { parse?: (d: unknown) => unknown } | undefined
+          const data = v && typeof v.parse === 'function' ? v.parse(args?.data) : args?.data
+          return (capture.handler as (p: { data?: unknown }) => unknown)({ data })
+        }
+      },
+    }
+    return api
+  }
+  return { createServerFn }
+})
+
+vi.mock('@tanstack/react-start/server', () => ({ getRequest: () => ({}) }))
+
+vi.mock('@/lib/session', () => ({ getCurrentSession: vi.fn(async () => null) }))
+
+vi.mock('@/server/desktop-bootstrap', () => ({ ensureLocalShadowUser: vi.fn() }))
+
+vi.mock('@/server/remote-auth', () => ({
+  readRemoteAuth: vi.fn(async () => null),
+  writeRemoteAuth: H.writeRemoteAuth,
+  writeRemoteSession: H.writeRemoteSession,
+  clearRemoteAuth: vi.fn(),
+}))
+
+vi.mock('@/server/entitlements-token', () => ({
+  generateEntitlementsToken: H.generateEntitlementsToken,
+}))
+
+vi.mock('@/server/middlewares/rate-limit', () => ({ checkAuthRateLimit: H.checkAuthRateLimit }))
+
+import { exchangeRemoteTokenFn } from '../serverFns/auth/session'
+
+describe('exchangeRemoteTokenFn 双路径落盘（A10 修复）', () => {
+  const saved = process.env.DEPLOY_TARGET
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.stubGlobal('fetch', H.fetch)
+  })
+
+  afterEach(() => {
+    vi.unstubAllEnvs()
+    vi.unstubAllGlobals()
+    if (saved === undefined) delete process.env.DEPLOY_TARGET
+    else process.env.DEPLOY_TARGET = saved
+  })
+
+  it('signedToken 路径（生产 SaaS 恒发）：session 块 + token 双写', async () => {
+    process.env.DEPLOY_TARGET = 'desktop'
+    H.fetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        user: { id: 'cloud-1', name: 'Cloud 用户', email: 'cloud@example.com' },
+        planName: 'pro',
+        features: { sync: true },
+        signedToken: 'signed-abc',
+      }),
+    })
+    const res = await exchangeRemoteTokenFn({ data: { token: 'tok-123' } })
+    expect(res).toEqual({ success: true, userId: 'cloud-1', planName: 'pro' })
+    // 修复断言：session 块必须落盘（缺它 readRemoteAuth 恒 null → 云身份不激活）
+    expect(H.writeRemoteSession).toHaveBeenCalledWith('cloud-1', 'pro', 'tok-123')
+    expect(H.writeRemoteAuth).toHaveBeenCalledWith('signed-abc', 'tok-123')
+    expect(H.generateEntitlementsToken).not.toHaveBeenCalled()
+  })
+
+  it('degraded 路径（本地无签名 secret）：仅写 session 块，不写 writeRemoteAuth', async () => {
+    process.env.DEPLOY_TARGET = 'desktop'
+    H.fetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ user: { id: 'cloud-2' }, planName: 'free' }),
+    })
+    H.generateEntitlementsToken.mockResolvedValue(null)
+    const res = await exchangeRemoteTokenFn({ data: { token: 'tok-456' } })
+    expect(res).toEqual({ success: true, userId: 'cloud-2', planName: 'free', degraded: true })
+    expect(H.writeRemoteSession).toHaveBeenCalledWith('cloud-2', 'free', 'tok-456')
+    expect(H.writeRemoteAuth).not.toHaveBeenCalled()
+  })
+})

package/src/server/__tests__/remote-auth.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest"
 import { promises as fs } from "node:fs"
 import os from "node:os"
 import path from "node:path"
@@ -70,3 +70,133 @@ describe("remote-auth（Electron fs 持久层）", () => {
     expect(await readRemoteAuth()).toBeNull()
   })
 })
+
+// ---------- A12 desktop codec 接缝（safeStorage 透明加解密） ----------
+
+// stub codec（Pro 域 entry.cjs/main.ts 注入的 globalThis.__allblueDesktopCodec
+// 同契约形态：XOR 对称可逆，密文经 enc:v1: 前缀 + base64 落盘，与真实现等价）
+function stubCodec() {
+  const KEY = 0x5a
+  const xor = (b: Buffer) => Buffer.from([...b].map((x) => x ^ KEY))
+  return {
+    encrypt: async (plain: string) => `enc:v1:${xor(Buffer.from(plain, "utf8")).toString("base64")}`,
+    decrypt: async (raw: string) => {
+      if (!raw.startsWith("enc:v1:")) return raw
+      return xor(Buffer.from(raw.slice("enc:v1:".length), "base64")).toString("utf8")
+    },
+  }
+}
+
+describe("remote-auth desktop codec 接缝（A12）", () => {
+  let dir: string
+  const saved: Record<string, string | undefined> = {}
+  const savedCodec = { value: undefined as unknown }
+
+  beforeEach(async () => {
+    for (const k of ENV_KEYS) saved[k] = process.env[k]
+    dir = await fs.mkdtemp(path.join(os.tmpdir(), "remote-auth-codec-test-"))
+    process.env.DESKTOP_USER_DATA_DIR = dir
+    process.env.DEPLOY_TARGET = "desktop"
+    savedCodec.value = globalThis.__allblueDesktopCodec
+  })
+
+  afterEach(async () => {
+    globalThis.__allblueDesktopCodec = savedCodec.value as typeof globalThis.__allblueDesktopCodec
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k]
+      else process.env[k] = saved[k]
+    }
+    await fs.rm(dir, { recursive: true, force: true })
+  })
+
+  it("codec 注入：密文落盘（磁盘字节不含明文 token）且读回一致", async () => {
+    globalThis.__allblueDesktopCodec = stubCodec()
+    await writeRemoteAuth("tok-1", "stale-st")
+    await writeRemoteSession("user-1", "pro", "fresh-st")
+    const raw = await fs.readFile(path.join(dir, "remote-auth.json"), "utf8")
+    expect(raw.startsWith("enc:v1:")).toBe(true)
+    expect(raw).not.toContain("fresh-st")
+    expect(raw).not.toContain("stale-st")
+    expect(raw).not.toContain("tok-1")
+    expect(raw).not.toContain("sessionToken")
+    expect(() => JSON.parse(raw)).toThrow()
+    // roundtrip：读回一致
+    expect(await readRemoteAuth()).toMatchObject({
+      userId: "user-1",
+      planName: "pro",
+      sessionToken: "fresh-st",
+    })
+  })
+
+  it("codec 注入但磁盘为旧明文：按明文读取（平滑迁移，无前缀直通）", async () => {
+    globalThis.__allblueDesktopCodec = stubCodec()
+    const legacy = JSON.stringify({
+      session: { userId: "user-1", planName: "pro", sessionToken: "legacy-st" },
+    })
+    await fs.writeFile(path.join(dir, "remote-auth.json"), legacy, "utf8")
+    expect(await readRemoteAuth()).toMatchObject({ sessionToken: "legacy-st" })
+  })
+
+  it("无 codec：行为不变——明文落盘（现状回归锚，逐字节兼容）", async () => {
+    globalThis.__allblueDesktopCodec = undefined
+    await writeRemoteAuth("tok-1")
+    await writeRemoteSession("user-1", "pro", "fresh-st")
+    const raw = await fs.readFile(path.join(dir, "remote-auth.json"), "utf8")
+    const parsed = JSON.parse(raw) as { session?: { sessionToken?: string } }
+    expect(parsed.session?.sessionToken).toBe("fresh-st") // 明文形态 = 现状
+    expect(await readRemoteAuth()).toMatchObject({ sessionToken: "fresh-st" })
+  })
+
+  it("codec 降级形态（encrypt 返回无前缀明文）：不二次加前缀、明文落盘可读回", async () => {
+    // safeStorage 不可用降级由 Pro 域算子收敛为「原样明文」输出——接缝必须
+    // 原样落盘，不得对降级明文再补前缀（否则读回解密必败）
+    globalThis.__allblueDesktopCodec = {
+      encrypt: async (p: string) => p,
+      decrypt: async (r: string) => r,
+    }
+    await writeRemoteSession("user-1", "pro", "fresh-st")
+    const raw = await fs.readFile(path.join(dir, "remote-auth.json"), "utf8")
+    expect(raw.startsWith("enc:v1:")).toBe(false)
+    expect((JSON.parse(raw) as { session?: { sessionToken?: string } }).session?.sessionToken).toBe(
+      "fresh-st",
+    )
+    expect(await readRemoteAuth()).toMatchObject({ sessionToken: "fresh-st" })
+  })
+
+  it("密文文件但 codec 缺失（独立预检分支）：warn + null（视为未登录，下次写入自愈）", async () => {
+    // 旧壳读到新格式 / 异常态：磁盘密文在场、globalThis codec 未注入——
+    // readFile 显式预检 + warn + null，不抛错反噬调用方。warn 断言钉死独立
+    // 预检分支（防空转：无预检时 JSON.parse 抛错同样落 catch → null，结果
+    // 相同但丢诊断信号）
+    globalThis.__allblueDesktopCodec = undefined
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+    try {
+      await fs.writeFile(
+        path.join(dir, "remote-auth.json"),
+        `enc:v1:${Buffer.from('{"session":{"userId":"user-1"}}').toString("base64")}`,
+        "utf8",
+      )
+      expect(await readRemoteAuth()).toBeNull()
+      expect(
+        warnSpy.mock.calls.some((args) => String(args[0]).includes("codec 未注入")),
+      ).toBe(true)
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
+  it("密文在场但 decrypt 抛错（IPC 失败/密文损坏）：catch 吞错 → null", async () => {
+    globalThis.__allblueDesktopCodec = {
+      encrypt: async (p: string) => `enc:v1:${Buffer.from(p).toString("base64")}`,
+      decrypt: async () => {
+        throw new Error("codec rpc 超时")
+      },
+    }
+    await fs.writeFile(
+      path.join(dir, "remote-auth.json"),
+      `enc:v1:${Buffer.from("garbage-not-json").toString("base64")}`,
+      "utf8",
+    )
+    expect(await readRemoteAuth()).toBeNull()
+  })
+})

package/src/server/ai-gateway/__tests__/tools-authorization.test.ts

@@ -22,7 +22,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest"
 
 const mocks = vi.hoisted(() => ({
   user: { findUnique: vi.fn() },
-  kb: { findFirst: vi.fn() },
+  kb: { findFirst: vi.fn(), findUnique: vi.fn().mockResolvedValue(null) },
   doc: { findMany: vi.fn(), findFirst: vi.fn(), create: vi.fn(), update: vi.fn(), delete: vi.fn() },
   ragSearch: vi.fn(),
   resolveKnowledgeAiConfig: vi.fn(async () => ({})),
@@ -147,11 +147,13 @@ describe("document_action 归属", () => {
 
   it("create：属主 + 绑定内 → 写入并带 createdBy", async () => {
     mocks.kb.findFirst.mockResolvedValue({ id: "kb-1" })
+    mocks.kb.findUnique.mockResolvedValue({ workspaceId: "ws-9" })
     mocks.doc.create.mockResolvedValue({ id: "d-new", kbId: "kb-1", title: "t", content: "" })
     const out = await run({ action: "create", knowledgeBaseId: "kb-1", title: "t" }, { context: ctxWith(["kb-1"]) })
     expect(out).toEqual({ success: true, documentId: "d-new" })
+    // P2 A7：冗余同步 scope 列写时快照取 kb.workspaceId
     expect(mocks.doc.create).toHaveBeenCalledWith({
-      data: expect.objectContaining({ kbId: "kb-1", createdBy: USER }),
+      data: expect.objectContaining({ kbId: "kb-1", createdBy: USER, syncWorkspaceId: "ws-9" }),
     })
   })
 

package/src/server/ai-gateway/tools/server.ts

@@ -187,6 +187,11 @@ const documentCrudTool = documentCrudDef.server<AppContext>(
       if (action === "create") {
         if (!knowledgeBaseId) return { success: false, error: "knowledgeBaseId is required" }
         await assertToolKbWriteAccess(knowledgeBaseId, context)
+        // 冗余同步 scope 列来源（P2 A7）：kb.workspaceId 写时快照
+        const kbRow = await prisma.knowledgeBase.findUnique({
+          where: { id: knowledgeBaseId },
+          select: { workspaceId: true },
+        })
         if (parentId) {
           // 挂载点必须存在且属于同一 KB（防把文档挂到他人 KB 节点下）
           const parent = await prisma.knowledgeDocument.findFirst({
@@ -202,6 +207,8 @@ const documentCrudTool = documentCrudDef.server<AppContext>(
             kbId: knowledgeBaseId,
             parentId: parentId || null,
             createdBy: context.userId,
+            // null（个人库）= 一期不进同步面（stay local）
+            syncWorkspaceId: kbRow?.workspaceId ?? null,
           },
         })
         const aiConfig = await getPorts().infra.resolveKnowledgeAiConfig(knowledgeBaseId)

package/src/server/desktop-bootstrap.ts

@@ -25,6 +25,7 @@
 
 import { randomUUID } from 'node:crypto'
 import { prisma } from '@allbluecn/database'
+import type { Prisma } from '@allbluecn/database'
 import { ensureBuiltinIndependentProject } from '@/server/builtin-project'
 import {
   GUEST_EMAIL,
@@ -54,7 +55,24 @@ function shadowBgColor(seed: string): string {
 export async function ensureLocalShadowUser(): Promise<string> {
   if (!isDesktopServer()) return GUEST_USER_ID
 
-  await prisma.user.upsert({
+  await ensureLocalShadowUserWith(prisma)
+
+  await ensureBuiltinIndependentProject(GUEST_USER_ID)
+  return GUEST_USER_ID
+}
+
+/**
+ * 影子用户 upsert 主体（可传事务客户端，A9 抽取）：公开无参包装
+ * （ensureLocalShadowUser）的语义不变，反向转移（ownership-transfer 的
+ * reverseTransferOwnership）在**同一事务内**调本函数重建 guest 行——原实现
+ * 直用模块级 prisma 单例，事务内调用会绕过 tx（属主翻转引用的 FK 目标必须与
+ * 翻转同事务存在，否则并发删除/回滚会留孤儿）。
+ * 只含 users 行 upsert：内置独立项目走 ensureBuiltinIndependentProject（模块级
+ * prisma），由登出后的 getSessionFn guest 分支懒补（项目行经反向转移已回 guest
+ * 属主，通常已存在）。
+ */
+export async function ensureLocalShadowUserWith(tx: Prisma.TransactionClient): Promise<string> {
+  await tx.user.upsert({
     where: { id: GUEST_USER_ID },
     create: {
       id: GUEST_USER_ID,
@@ -68,7 +86,5 @@ export async function ensureLocalShadowUser(): Promise<string> {
     },
     update: {},
   })
-
-  await ensureBuiltinIndependentProject(GUEST_USER_ID)
   return GUEST_USER_ID
 }

package/src/server/desktop-session-merge.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+
+// 桌面轻量云身份组装（桌面本地优先 P2 / A10）：RemoteAuthData → Session 的
+// 单一组装点 + getCurrentSession 的桌面回落入口。独立模块原因：lib/session
+// 的回落需要组装函数，而 lib/session 不得 import serverFns/**（serverFns/
+// auth/session 反向 import lib/session，会成环）——故从 serverFns/auth/
+// session.ts 抽出 buildRemoteSession 共享（字段逐字一致，两处不再漂移）。
+// 本模块保持纯数据组装 + remote-auth 纯 fs 读取（node:fs + env 守卫），
+// 无 prisma/server 重依赖链；lib/session 对本模块的单条 import 经 eslint
+// 文件级豁免放行（apps/web/eslint.config.mjs）。
+import { DEFAULT_AI_MODEL, DEFAULT_AI_PROVIDER } from '@/lib/ai/default-model'
+import { isDesktopServer } from '@/server/desktop-guest'
+import { readRemoteAuth } from '@/server/remote-auth'
+import type { RemoteAuthData } from '@/server/remote-auth'
+import type { Session } from '@/lib/session'
+
+export function buildRemoteSession(data: RemoteAuthData): Session {
+  return {
+    user: {
+      id: data.userId,
+      name: data.username ?? data.userId,
+      email: data.email,
+      role: (data.role ?? 'USER') as 'USER' | 'ADMIN' | 'SUPER_ADMIN',
+      isGuest: false,
+      // 云端头像透传（SaaS desktop-callback 下发；缺省回落首字母，修复桌面端
+      // 当前用户头像不显示）
+      avatarConfig: data.avatarConfig,
+      bgShape: data.bgShape,
+      bgColor: data.bgColor,
+      aiProvider: DEFAULT_AI_PROVIDER,
+      aiModel: DEFAULT_AI_MODEL,
+      hasAiKey: false,
+    },
+    expires: 'never',
+  }
+}
+
+/**
+ * getCurrentSession 的桌面回落段（优先级链：authjs session → desktop
+ * remoteAuth → null）：authjs session 无效且为 desktop 部署时，读
+ * remote-auth.json 组装轻量云身份（user.id = 云 userId）。desktop 判定
+ * 先于 fs 读取（非 desktop 恒 null、零 IO），调用方无需重复判定。
+ */
+export async function getDesktopRemoteSession(): Promise<Session | null> {
+  if (!isDesktopServer()) return null
+  const remoteAuth = await readRemoteAuth()
+  if (!remoteAuth) return null
+  return buildRemoteSession(remoteAuth)
+}

package/src/server/remote-auth.ts

@@ -3,6 +3,14 @@
 // backend serverFn 进程内 fs 直达，无 IPC）。Tauri invoke 实现已随
 // Tauri 2 → Electron 迁移清除（2026-10-31）；云/Web 部署（DEPLOY_TARGET
 // 非 desktop）恒 null / no-op，行为与旧版一致。
+//
+// A12 敏感文件加密（desktop 本地优先 P2）：文件含云会话 token（敏感），
+// 内部 fs IO 经 globalThis.__allblueDesktopCodec 透明加解密（codec 由 Electron
+// Pro 域注入：main 直连 safeStorage，backend 经 entry.cjs parentPort IPC 请求
+// main——safeStorage 是 main 进程 API，复审⑥ P2-13）。接缝缺省（web/OSS/云/
+// dev 非 desktop/旧壳）行为逐字节不变：明文落盘、明文可读。密文格式
+// enc:v1:<base64>（与 Pro 仓 cloud-session.json 同前缀）；无前缀旧文件直通
+// （平滑迁移：读取兼容，下次写入自然升级密文）。
 import { promises as fs } from "node:fs"
 import path from "node:path"
 
@@ -39,13 +47,59 @@ function filePath(): string | null {
   return path.join(dir, "remote-auth.json")
 }
 
+// ---------- A12 desktop codec 接缝（与 Pro 仓 login.ts 同型） ----------
+
+/** 密文前缀标记（Pro 仓 electron/sync/encfile.ts ENC_PREFIX，两仓统一） */
+const DESKTOP_ENC_PREFIX = "enc:v1:"
+
+/**
+ * desktop codec 接缝契约：encrypt(plain) 返回最终落盘内容（enc:v1: 密文，
+ * 或 safeStorage 不可用时降级明文——不二次加前缀）；decrypt(raw) 收磁盘原文
+ * （识别前缀解密，旧明文直通）。Pro 域注入：main 直连 safeStorage（globalThis
+ * 自持），backend 经 entry.cjs parentPort IPC 请求 main（同 conflict-rpc 模型）。
+ */
+interface DesktopCodec {
+  encrypt(plain: string): Promise<string | Buffer>
+  decrypt(cipher: string): Promise<string>
+}
+
+// 调用时点读取（非模块加载期捕获）——backend entry.cjs 在 nitro 动态 import
+// 前顶装，规避注入时序；写放如返回 Buffer（原始密文字节）则补前缀 + base64。
+declare global {
+  var __allblueDesktopCodec: DesktopCodec | undefined
+}
+
+async function encodeDiskContent(plain: string): Promise<string> {
+  const codec = globalThis.__allblueDesktopCodec
+  if (!codec) return plain
+  const out = await codec.encrypt(plain)
+  if (typeof out === "string") return out
+  return `${DESKTOP_ENC_PREFIX}${Buffer.from(out).toString("base64")}`
+}
+
+async function decodeDiskContent(raw: string): Promise<string> {
+  if (!raw.startsWith(DESKTOP_ENC_PREFIX)) return raw
+  const codec = globalThis.__allblueDesktopCodec
+  if (!codec) throw new Error("密文 remote-auth 但 codec 未注入")
+  return await codec.decrypt(raw)
+}
+
 async function readFile(): Promise<RemoteAuthFile | null> {
   const file = filePath()
   if (!file) return null
   try {
-    return JSON.parse(await fs.readFile(file, "utf8")) as RemoteAuthFile
+    const raw = await fs.readFile(file, "utf8")
+    // 密文形态（带前缀）必须经 codec 解密；旧明文按原样解析（迁移兼容，
+    // 不依赖 codec 在场）。密文但 codec 缺失（旧壳/异常态）→ 警告并视为
+    // 未登录（下次登录写入自愈），不抛错反噬调用方。
+    if (!raw.startsWith(DESKTOP_ENC_PREFIX)) return JSON.parse(raw) as RemoteAuthFile
+    if (!globalThis.__allblueDesktopCodec) {
+      console.warn("[remote-auth] 密文 remote-auth 但 codec 未注入（视为未登录，下次写入自愈）")
+      return null
+    }
+    return JSON.parse(await decodeDiskContent(raw)) as RemoteAuthFile
   } catch {
-    // 文件不存在/损坏均视为未登录（损坏文件在下次写入时被覆盖自愈）
+    // 文件不存在/损坏/解密失败均视为未登录（损坏文件在下次写入时被覆盖自愈）
     return null
   }
 }
@@ -53,9 +107,13 @@ async function readFile(): Promise<RemoteAuthFile | null> {
 async function writeFile(next: RemoteAuthFile): Promise<void> {
   const file = filePath()
   if (!file) return
+  // codec 在场 → 密文落盘（encodeDiskContent 可能因 IPC 异常抛错：宁可不写
+  // ——由 writeRemoteAuth/writeRemoteSession 的既有 catch 吞掉并告警——不做
+  // 明文兜底）；无 codec → 明文（行为=现状）。
+  const content = await encodeDiskContent(JSON.stringify(next, null, 2))
   const tmp = `${file}.tmp`
   // 0600：文件含云会话 token（敏感），限属主读写；tmp+rename 原子替换防半写
-  await fs.writeFile(tmp, JSON.stringify(next, null, 2), { mode: 0o600 })
+  await fs.writeFile(tmp, content, { mode: 0o600 })
   await fs.rename(tmp, file)
 }
 

package/src/server/serverFns/__tests__/knowledge-readable-kb.test.ts

@@ -223,4 +223,25 @@ describe('createDocumentFn：parentId 同库校验 + maxSort 同事务（审计
       expect.objectContaining({ data: expect.objectContaining({ sortOrder: 4, parentId: 'doc-parent', kbId: 'kb-1' }) }),
     )
   })
+
+  // P2 A7：冗余同步 scope 列写时快照——文档创建即取 kb.workspaceId
+  it('syncWorkspaceId 取 kb.workspaceId（工作区库）', async () => {
+    m.knowledgeBase.findFirst.mockResolvedValue({ id: 'kb-1', workspaceId: 'ws-1' })
+    m.knowledgeDocument.aggregate.mockResolvedValue({ _max: { sortOrder: -1 } })
+    m.knowledgeDocument.create.mockResolvedValue({ id: 'doc-new', title: '新文档', type: 'doc', parentId: null })
+    await createDocumentFn({ data: { kbId: 'kb-1', title: '无父文档' } })
+    expect(m.knowledgeDocument.create).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ syncWorkspaceId: 'ws-1' }) }),
+    )
+  })
+
+  it('syncWorkspaceId 为 null（个人库）——stay local 不同步', async () => {
+    m.knowledgeBase.findFirst.mockResolvedValue({ id: 'kb-1', workspaceId: null })
+    m.knowledgeDocument.aggregate.mockResolvedValue({ _max: { sortOrder: -1 } })
+    m.knowledgeDocument.create.mockResolvedValue({ id: 'doc-new', title: '新文档', type: 'doc', parentId: null })
+    await createDocumentFn({ data: { kbId: 'kb-1', title: '无父文档' } })
+    expect(m.knowledgeDocument.create).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ syncWorkspaceId: null }) }),
+    )
+  })
 })

package/src/server/serverFns/__tests__/workspace.test.ts

@@ -100,7 +100,9 @@ const mocks = vi.hoisted(() => ({
   auditLogCreate: vi.fn(),
   knowledgeBaseDeleteMany: vi.fn(),
   knowledgeBaseUpdateMany: vi.fn(),
+  knowledgeBaseFindMany: vi.fn().mockResolvedValue([]),
   knowledgeBaseCreate: vi.fn(),
+  knowledgeDocumentUpdateMany: vi.fn(),
   wkbCreate: vi.fn(),
   usageRecordDeleteMany: vi.fn(),
   aiUsageLogDeleteMany: vi.fn(),
@@ -165,6 +167,10 @@ vi.mock("@allbluecn/database", () => ({
       create: mocks.knowledgeBaseCreate,
       deleteMany: mocks.knowledgeBaseDeleteMany,
       updateMany: mocks.knowledgeBaseUpdateMany,
+      findMany: mocks.knowledgeBaseFindMany,
+    },
+    knowledgeDocument: {
+      updateMany: mocks.knowledgeDocumentUpdateMany,
     },
     workspaceKnowledgeBase: {
       create: mocks.wkbCreate,
@@ -198,6 +204,10 @@ vi.mock("@allbluecn/database", () => ({
           create: mocks.knowledgeBaseCreate,
           deleteMany: mocks.knowledgeBaseDeleteMany,
           updateMany: mocks.knowledgeBaseUpdateMany,
+          findMany: mocks.knowledgeBaseFindMany,
+        },
+        knowledgeDocument: {
+          updateMany: mocks.knowledgeDocumentUpdateMany,
         },
         workspaceKnowledgeBase: {
           create: mocks.wkbCreate,
@@ -447,6 +457,42 @@ describe("deleteWorkspaceFn", () => {
     });
   });
 
+  it("解绑模式（keep）级联清空文档冗余 scope 列（P2 A7）", async () => {
+    mocks.workspaceFindUnique.mockResolvedValue({ ownerId: "u1" });
+    mocks.projectCount.mockResolvedValue(0);
+    mocks.workspaceDelete.mockResolvedValue({ id: "ws1" });
+    mocks.knowledgeBaseFindMany.mockResolvedValue([{ id: "kb1" }, { id: "kb2" }]);
+
+    const result = await deleteWorkspaceFn({
+      data: { workspaceId: "ws1", knowledgeBaseMode: "keep" },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(mocks.knowledgeBaseUpdateMany).toHaveBeenCalledWith({
+      where: { workspaceId: "ws1" },
+      data: { workspaceId: null },
+    });
+    expect(mocks.knowledgeDocumentUpdateMany).toHaveBeenCalledWith({
+      where: { kbId: { in: ["kb1", "kb2"] } },
+      data: { syncWorkspaceId: null },
+    });
+  });
+
+  it("delete 模式硬删知识库，文档随 FK 级联硬删、不动 scope 列", async () => {
+    mocks.workspaceFindUnique.mockResolvedValue({ ownerId: "u1" });
+    mocks.projectCount.mockResolvedValue(0);
+    mocks.workspaceDelete.mockResolvedValue({ id: "ws1" });
+
+    const result = await deleteWorkspaceFn({
+      data: { workspaceId: "ws1", knowledgeBaseMode: "delete" },
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(mocks.knowledgeBaseDeleteMany).toHaveBeenCalledWith({ where: { workspaceId: "ws1" } });
+    expect(mocks.knowledgeBaseFindMany).not.toHaveBeenCalled();
+    expect(mocks.knowledgeDocumentUpdateMany).not.toHaveBeenCalled();
+  });
+
   it("clear 模式删除所有项目后删除工作空间", async () => {
     mocks.workspaceFindUnique.mockResolvedValue({ ownerId: "u1" });
     mocks.projectCount.mockResolvedValue(3);