@allbluecn/web-app 0.12.0 → 0.12.3

package/src/server/serverFns/design/settings.ts

@@ -18,7 +18,6 @@
 import { createServerFn } from '@tanstack/react-start'
 import { getRequest } from '@tanstack/react-start/server'
 import { z } from 'zod'
-import { prisma } from '@allbluecn/database'
 import { requireAuth } from '@/server/auth-helpers'
 import crypto from 'crypto'
 
@@ -28,6 +27,7 @@ function generateToken(): string {
 
 export const getDesignSettingsFn = createServerFn({ method: 'GET' })
   .handler(async () => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     const userId = session.user!.id!
@@ -44,6 +44,7 @@ export const getDesignSettingsFn = createServerFn({ method: 'GET' })
 export const generateSketchTokenFn = createServerFn({ method: 'POST' })
   .validator(z.object({}))
   .handler(async () => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     const userId = session.user!.id!
@@ -62,6 +63,7 @@ const deleteSchema = z.object({
 export const deleteSketchTokenFn = createServerFn({ method: 'POST' })
   .validator(deleteSchema)
   .handler(async () => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     const userId = session.user!.id!

package/src/server/serverFns/design.ts

@@ -18,12 +18,12 @@
 import { createServerFn } from "@tanstack/react-start"
 import { getRequest } from "@tanstack/react-start/server"
 import { z } from "zod"
-import { prisma } from "@allbluecn/database"
 import { requireAuth } from "@/server/auth-helpers"
 
 export const listDesignProjectsFn = createServerFn({ method: "GET" })
   .validator(z.object({}).optional())
   .handler(async () => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     return prisma.designProject.findMany({
@@ -49,6 +49,7 @@ export const listDesignProjectsFn = createServerFn({ method: "GET" })
 export const getDesignProjectFn = createServerFn({ method: "GET" })
   .validator(z.object({ id: z.string() }))
   .handler(async ({ data }) => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     return prisma.designProject.findFirst({
@@ -80,6 +81,7 @@ export const getDesignProjectFn = createServerFn({ method: "GET" })
 export const getArtboardFn = createServerFn({ method: "GET" })
   .validator(z.object({ id: z.string() }))
   .handler(async ({ data }) => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     const artboard = await prisma.artboard.findFirst({
@@ -95,6 +97,7 @@ export const getArtboardFn = createServerFn({ method: "GET" })
 export const deleteDesignProjectFn = createServerFn({ method: "POST" })
   .validator(z.object({ id: z.string() }))
   .handler(async ({ data }) => {
+    const { prisma } = await import('@allbluecn/database')
     const request = getRequest()
     const session = await requireAuth(request)
     const project = await prisma.designProject.findFirst({

package/src/server/serverFns/email-unsubscribe.ts

@@ -17,7 +17,6 @@
 
 import { createServerFn } from '@tanstack/react-start'
 import { z } from 'zod'
-import { prisma } from '@allbluecn/database'
 import { checkAuthRateLimit } from '@/server/middlewares/rate-limit'
 import { verifyUnsubscribeToken } from '@/server/email/deliverability'
 
@@ -29,6 +28,7 @@ export interface UnsubscribeByEmailTokenResult {
 export const unsubscribeByEmailTokenFn = createServerFn({ method: 'GET' })
   .validator(z.object({ token: z.string().min(1) }))
   .handler(async ({ data }): Promise<UnsubscribeByEmailTokenResult> => {
+    const { prisma } = await import('@allbluecn/database')
     // 防 token 爆破扫描：单 IP 15 分钟内最多 20 次
     await checkAuthRateLimit('unsubscribe', 20, 15 * 60 * 1000)
 

package/src/server/serverFns/harness/__tests__/attach-guards.spec.ts

@@ -0,0 +1,45 @@
+import { beforeEach, expect, it, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  runFindFirst: vi.fn(),
+  storyFindFirst: vi.fn(),
+  kbFindFirst: vi.fn(),
+  prdFindFirst: vi.fn(),
+}))
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    generationRun: { findFirst: mocks.runFindFirst },
+    story: { findFirst: mocks.storyFindFirst },
+    knowledgeBase: { findFirst: mocks.kbFindFirst },
+    pRD: { findFirst: mocks.prdFindFirst },
+  },
+}))
+import { assertRunOwnership, assertStoryOwnership, assertKbOwnership, assertPrdOwnership } from "../attach-guards"
+
+beforeEach(() => vi.resetAllMocks())
+
+it("assertRunOwnership：本人返回 run，非本人抛错", async () => {
+  const run = { id: "run-1", artifacts: [{ url: "https://x/1.png" }], result: {}, status: "completed", activity: "image" }
+  mocks.runFindFirst.mockResolvedValueOnce(run).mockResolvedValueOnce(null)
+  await expect(assertRunOwnership("run-1", "u1")).resolves.toBe(run)
+  await expect(assertRunOwnership("run-1", "u2")).rejects.toThrow("Generation run not found")
+  expect(mocks.runFindFirst).toHaveBeenLastCalledWith({ where: { id: "run-1", userId: "u2" } })
+})
+
+it("assertStoryOwnership：owner 匹配放行，否则抛错", async () => {
+  mocks.storyFindFirst.mockResolvedValueOnce({ id: "st-1" }).mockResolvedValueOnce(null)
+  await expect(assertStoryOwnership("st-1", "u1")).resolves.toBeTruthy()
+  await expect(assertStoryOwnership("st-1", "u2")).rejects.toThrow("Story not found")
+  expect(mocks.storyFindFirst).toHaveBeenLastCalledWith({ where: { id: "st-1", project: { ownerId: "u2" } } })
+})
+
+it("assertKbOwnership / assertPrdOwnership 同构", async () => {
+  mocks.kbFindFirst.mockResolvedValueOnce({ id: "kb-1" }).mockResolvedValueOnce(null)
+  mocks.prdFindFirst.mockResolvedValueOnce({ id: "prd-1" }).mockResolvedValueOnce(null)
+  await expect(assertKbOwnership("kb-1", "u1")).resolves.toBeTruthy()
+  await expect(assertKbOwnership("kb-1", "u2")).rejects.toThrow("Knowledge base not found")
+  await expect(assertPrdOwnership("prd-1", "u1")).resolves.toBeTruthy()
+  await expect(assertPrdOwnership("prd-1", "u2")).rejects.toThrow("PRD not found")
+  expect(mocks.kbFindFirst).toHaveBeenLastCalledWith({ where: { id: "kb-1", userId: "u2", isDeleted: false } })
+  expect(mocks.prdFindFirst).toHaveBeenLastCalledWith({ where: { id: "prd-1", userId: "u2" } })
+})

package/src/server/serverFns/harness/__tests__/attach-prototype.spec.ts

@@ -0,0 +1,69 @@
+import { beforeEach, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+
+const mocks = vi.hoisted(() => ({
+  request: new Request("https://allblue.test/attach-prd"),
+  auth: vi.fn(),
+  feature: vi.fn(),
+  run: vi.fn(),
+  prd: vi.fn(),
+  pageFindFirst: vi.fn(),
+  pageUpdate: vi.fn(),
+  runUpdate: vi.fn(),
+}))
+vi.mock("@tanstack/react-start", () => ({ createServerFn: () => ({ validator: (schema: ZodType) => ({ handler: (fn: (args: { data: unknown }) => unknown) => async (args: { data: unknown }) => fn({ data: schema.parse(args.data) }) }) }) }))
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => mocks.request }))
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: mocks.auth }))
+vi.mock("@/server/entitlements", () => ({ requireFeature: mocks.feature }))
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    generationRun: { findFirst: mocks.run, update: mocks.runUpdate },
+    pRD: { findFirst: mocks.prd },
+    pRDPage: { findFirst: mocks.pageFindFirst, update: mocks.pageUpdate },
+  },
+}))
+import { attachPrototypeToPrdFn } from "../attach-prototype"
+
+const RUN_PROTO = {
+  id: "run-1", userId: "u1", status: "completed", activity: "image",
+  result: { message: "原型", components: [{ type: "button", source: "builtin", name: "按钮" }] },
+  artifacts: [], input: {}, usage: {}, startedAt: new Date(), finishedAt: new Date(),
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "u1" } })
+  mocks.run.mockResolvedValue(RUN_PROTO)
+  mocks.prd.mockResolvedValue({ id: "prd-1" })
+  mocks.pageFindFirst.mockResolvedValue({ id: "page-1", prdId: "prd-1" })
+  mocks.pageUpdate.mockResolvedValue({ id: "page-1", canvas: RUN_PROTO.result })
+  mocks.runUpdate.mockResolvedValue(RUN_PROTO)
+})
+
+it("本人回流：组件树写入首页 canvas + linkedTarget", async () => {
+  const res = await attachPrototypeToPrdFn({ data: { generationRunId: "run-1", prdId: "prd-1" } })
+  expect(mocks.pageUpdate).toHaveBeenCalledWith({
+    where: { id: "page-1" },
+    data: { canvas: { message: "原型", components: [{ type: "button", source: "builtin", name: "按钮" }] } },
+  })
+  expect(mocks.runUpdate).toHaveBeenCalledWith({ where: { id: "run-1" }, data: { linkedTarget: { kind: "prd", targetId: "prd-1", at: expect.any(String) } } })
+  expect(res).toMatchObject({ pageId: "page-1", linkedTarget: { kind: "prd", targetId: "prd-1" } })
+})
+
+it("源非本人 / PRD 非本人 → 拒绝", async () => {
+  mocks.run.mockResolvedValueOnce(null)
+  await expect(attachPrototypeToPrdFn({ data: { generationRunId: "x", prdId: "prd-1" } })).rejects.toThrow("Generation run not found")
+  mocks.prd.mockResolvedValueOnce(null)
+  await expect(attachPrototypeToPrdFn({ data: { generationRunId: "run-1", prdId: "x" } })).rejects.toThrow("PRD not found")
+  expect(mocks.pageUpdate).not.toHaveBeenCalled()
+})
+
+it("PRD 无 page → 抛错（不静默建页）", async () => {
+  mocks.pageFindFirst.mockResolvedValue(null)
+  await expect(attachPrototypeToPrdFn({ data: { generationRunId: "run-1", prdId: "prd-1" } })).rejects.toThrow("PRD has no page")
+})
+
+it("result 无组件树 → 抛错", async () => {
+  mocks.run.mockResolvedValue({ ...RUN_PROTO, result: {} })
+  await expect(attachPrototypeToPrdFn({ data: { generationRunId: "run-1", prdId: "prd-1" } })).rejects.toThrow("no prototype components")
+})

package/src/server/serverFns/harness/__tests__/attach-to-kb.spec.ts

@@ -0,0 +1,86 @@
+import { beforeEach, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+
+const mocks = vi.hoisted(() => ({
+  request: new Request("https://allblue.test/attach-kb"),
+  auth: vi.fn(),
+  feature: vi.fn(),
+  run: vi.fn(),
+  kb: vi.fn(),
+  docAggregate: vi.fn(),
+  docCreate: vi.fn(),
+  docUpdate: vi.fn(),
+  runUpdate: vi.fn(),
+  indexDoc: vi.fn(),
+}))
+vi.mock("@tanstack/react-start", () => ({ createServerFn: () => ({ validator: (schema: ZodType) => ({ handler: (fn: (args: { data: unknown }) => unknown) => async (args: { data: unknown }) => fn({ data: schema.parse(args.data) }) }) }) }))
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => mocks.request }))
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: mocks.auth }))
+vi.mock("@/server/entitlements", () => ({ requireFeature: mocks.feature }))
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    generationRun: { findFirst: mocks.run, update: mocks.runUpdate },
+    knowledgeBase: { findFirst: mocks.kb },
+    knowledgeDocument: { aggregate: mocks.docAggregate, create: mocks.docCreate, update: mocks.docUpdate },
+  },
+}))
+vi.mock("@/server/ai-gateway/knowledge-index-core", () => ({ indexDocumentById: mocks.indexDoc }))
+import { attachToKbFn } from "../attach-to-kb"
+
+const RUN_TEXT = {
+  id: "run-1", userId: "u1", status: "completed", activity: "transcription",
+  result: { text: "会议记录全文" },
+  artifacts: [], input: {}, usage: {}, startedAt: new Date(), finishedAt: new Date(),
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "u1" } })
+  mocks.run.mockResolvedValue(RUN_TEXT)
+  mocks.kb.mockResolvedValue({ id: "kb-1" })
+  mocks.docAggregate.mockResolvedValue({ _max: { sortOrder: 3 } })
+  mocks.docCreate.mockResolvedValue({ id: "doc-1", title: "T" })
+  mocks.docUpdate.mockResolvedValue({ id: "doc-1" })
+  mocks.runUpdate.mockResolvedValue(RUN_TEXT)
+  mocks.indexDoc.mockResolvedValue({ indexed: 1 })
+})
+
+it("本人回流：三步写入（create 骨架 → update content → 索引）+ linkedTarget", async () => {
+  const res = await attachToKbFn({ data: { generationRunId: "run-1", kbId: "kb-1", title: "转写稿" } })
+  expect(mocks.docCreate).toHaveBeenCalledWith(expect.objectContaining({
+    data: expect.objectContaining({ kbId: "kb-1", title: "转写稿", type: "doc", sortOrder: 4 }),
+  }))
+  expect(mocks.docUpdate).toHaveBeenCalledWith(expect.objectContaining({
+    where: { id: "doc-1" },
+    data: expect.objectContaining({ content: { markdown: "会议记录全文" } }),
+  }))
+  expect(mocks.indexDoc).toHaveBeenCalledWith("doc-1")
+  expect(mocks.runUpdate).toHaveBeenCalledWith({ where: { id: "run-1" }, data: { linkedTarget: { kind: "kb", targetId: "kb-1", at: expect.any(String) } } })
+  expect(res).toMatchObject({ documentId: "doc-1", linkedTarget: { kind: "kb" } })
+})
+
+it("索引失败不阻塞回流（fire-and-forget + warn）", async () => {
+  mocks.indexDoc.mockRejectedValue(new Error("no ai key"))
+  const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+  try {
+    const res = await attachToKbFn({ data: { generationRunId: "run-1", kbId: "kb-1", title: "T" } })
+    expect(res).toMatchObject({ documentId: "doc-1" })
+    await new Promise((r) => setTimeout(r, 0))
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("no ai key"))
+  } finally {
+    warnSpy.mockRestore()
+  }
+})
+
+it("源非本人 / KB 非本人 → 拒绝", async () => {
+  mocks.run.mockResolvedValueOnce(null)
+  await expect(attachToKbFn({ data: { generationRunId: "x", kbId: "kb-1", title: "T" } })).rejects.toThrow("Generation run not found")
+  mocks.kb.mockResolvedValueOnce(null)
+  await expect(attachToKbFn({ data: { generationRunId: "run-1", kbId: "x", title: "T" } })).rejects.toThrow("Knowledge base not found")
+})
+
+it("无可提取正文 → 抛错且不建文档", async () => {
+  mocks.run.mockResolvedValue({ ...RUN_TEXT, result: {} })
+  await expect(attachToKbFn({ data: { generationRunId: "run-1", kbId: "kb-1", title: "T" } })).rejects.toThrow("no extractable text")
+  expect(mocks.docCreate).not.toHaveBeenCalled()
+})

package/src/server/serverFns/harness/__tests__/attach-to-story.spec.ts

@@ -0,0 +1,90 @@
+import { beforeEach, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+
+const mocks = vi.hoisted(() => ({
+  request: new Request("https://allblue.test/attach-story"),
+  auth: vi.fn(),
+  feature: vi.fn(),
+  run: vi.fn(),
+  story: vi.fn(),
+  attachmentCreate: vi.fn(),
+  attachmentUpdate: vi.fn(),
+  runUpdate: vi.fn(),
+  guardFetch: vi.fn(),
+}))
+vi.mock("@tanstack/react-start", () => ({ createServerFn: () => ({ validator: (schema: ZodType) => ({ handler: (fn: (args: { data: unknown }) => unknown) => async (args: { data: unknown }) => fn({ data: schema.parse(args.data) }) }) }) }))
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => mocks.request }))
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: mocks.auth }))
+vi.mock("@/server/entitlements", () => ({ requireFeature: mocks.feature }))
+vi.mock("@/server/fetch-guard", () => ({ assertFetchableUrl: mocks.guardFetch }))
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    generationRun: { findFirst: mocks.run, update: mocks.runUpdate },
+    story: { findFirst: mocks.story },
+    storyAttachment: { create: mocks.attachmentCreate, update: mocks.attachmentUpdate },
+  },
+}))
+import { attachToStoryFn } from "../attach-to-story"
+
+const RUN = {
+  id: "run-1", userId: "u1", status: "completed", activity: "image",
+  artifacts: [{ artifactId: "a1", runId: "run-1", threadId: "t1", name: "pic.png", mimeType: "image/png", size: 4, url: "https://cdn.test/pic.png" }],
+  result: {}, input: {}, usage: {}, startedAt: new Date(), finishedAt: new Date(),
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "u1" } })
+  mocks.run.mockResolvedValue(RUN)
+  mocks.story.mockResolvedValue({ id: "st-1" })
+  mocks.attachmentCreate.mockResolvedValue({ id: "att-1" })
+  mocks.runUpdate.mockResolvedValue(RUN)
+  vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response(new Uint8Array([1, 2, 3, 4]).buffer, { status: 200 })))
+})
+
+it("本人回流：fetch artifact → create 附件两段式 → 写 linkedTarget", async () => {
+  const res = await attachToStoryFn({ data: { generationRunId: "run-1", storyId: "st-1" } })
+  expect(mocks.guardFetch).toHaveBeenCalledWith("https://cdn.test/pic.png")
+  expect(mocks.attachmentCreate).toHaveBeenCalledWith(expect.objectContaining({
+    data: expect.objectContaining({
+      storyId: "st-1",
+      mimeType: "image/png",
+      storageUrl: "pending",
+      bytes: new Uint8Array([1, 2, 3, 4]),
+      fileSize: BigInt(4),
+    }),
+  }))
+  expect(mocks.attachmentUpdate).toHaveBeenCalledWith({ where: { id: "att-1" }, data: { storageUrl: "/api/attachments/att-1/content" } })
+  expect(mocks.runUpdate).toHaveBeenCalledWith({ where: { id: "run-1" }, data: { linkedTarget: { kind: "story", targetId: "st-1", at: expect.any(String) } } })
+  expect(res).toMatchObject({ attachmentId: "att-1", linkedTarget: { kind: "story", targetId: "st-1" } })
+})
+
+it("源非本人 → 拒绝且不写", async () => {
+  mocks.run.mockResolvedValue(null)
+  await expect(attachToStoryFn({ data: { generationRunId: "run-x", storyId: "st-1" } })).rejects.toThrow("Generation run not found")
+  expect(mocks.attachmentCreate).not.toHaveBeenCalled()
+})
+
+it("目标 story 非本人 → 拒绝且不写", async () => {
+  mocks.story.mockResolvedValue(null)
+  await expect(attachToStoryFn({ data: { generationRunId: "run-1", storyId: "st-x" } })).rejects.toThrow("Story not found")
+  expect(mocks.attachmentCreate).not.toHaveBeenCalled()
+})
+
+it("fetch 失败 → 抛错且不建附件", async () => {
+  vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("network down")))
+  await expect(attachToStoryFn({ data: { generationRunId: "run-1", storyId: "st-1" } })).rejects.toThrow("network down")
+  expect(mocks.attachmentCreate).not.toHaveBeenCalled()
+})
+
+it("artifact 超限（content-length 或实际字节）→ 抛错且不建附件", async () => {
+  const big = new Response(new Uint8Array(11 * 1024 * 1024).buffer, { status: 200, headers: { "content-length": String(11 * 1024 * 1024) } })
+  vi.stubGlobal("fetch", vi.fn().mockResolvedValue(big))
+  await expect(attachToStoryFn({ data: { generationRunId: "run-1", storyId: "st-1" } })).rejects.toThrow("Artifact too large")
+  expect(mocks.attachmentCreate).not.toHaveBeenCalled()
+
+  const noHeader = new Response(new Uint8Array(4).buffer, { status: 200 })
+  vi.stubGlobal("fetch", vi.fn().mockResolvedValue(noHeader))
+  const res = await attachToStoryFn({ data: { generationRunId: "run-1", storyId: "st-1" } })
+  expect(res).toMatchObject({ attachmentId: "att-1" })
+})

package/src/server/serverFns/harness/__tests__/cancel-run.test.ts

@@ -0,0 +1,146 @@
+// @vitest-environment node
+
+// cancel-run serverFn 归属与写入矩阵：未登录拒绝、无 active run 拒绝、
+// userId 进 where 保证归属（不泄露他人 run 存在性）、runId 可选限定、
+// driverEpoch 单调递增。mock 骨架与 sandbox-policy.test.ts 一致。
+
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (_config: unknown) => {
+    const api: {
+      _validator?: { parse: (input: unknown) => unknown }
+      validator: (schema: unknown) => typeof api
+      handler: (fn: (args: { data: unknown }) => Promise<unknown>) => (
+        args: { data: unknown },
+      ) => Promise<unknown>
+    } = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema
+        return this
+      },
+      handler(fn: any) {
+        return async (args: { data: unknown }) => {
+          let data = args?.data
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse(data)
+          }
+          return fn({ data })
+        }
+      },
+    }
+    return api
+  },
+}))
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }))
+
+const mocks = vi.hoisted(() => {
+  const findFirst = vi.fn()
+  const getCurrentSession = vi.fn()
+  const update = vi.fn(async () => undefined)
+  return { findFirst, getCurrentSession, update }
+})
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    chatRun: {
+      findFirst: mocks.findFirst,
+    },
+  },
+}))
+vi.mock("@/lib/session", () => ({
+  getCurrentSession: mocks.getCurrentSession,
+}))
+vi.mock("@/server/ai-gateway/persistence/run-store", () => ({
+  chatRunStore: () => ({ update: mocks.update }),
+}))
+
+import { cancelRunFn } from "../cancel-run"
+
+const OWNER = { id: "user-1", name: "owner", email: "owner@example.com" }
+
+describe("cancelRunFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.getCurrentSession.mockResolvedValue({ user: OWNER })
+  })
+
+  it("未登录拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue(null)
+    await expect(
+      cancelRunFn({ data: { threadId: "t-1" } }),
+    ).rejects.toThrow("Unauthorized")
+    expect(mocks.findFirst).not.toHaveBeenCalled()
+  })
+
+  it("无 active run 时拒绝，且不做任何写入", async () => {
+    mocks.findFirst.mockResolvedValue(null)
+
+    await expect(cancelRunFn({ data: { threadId: "t-1" } })).rejects.toThrow(
+      "No active run to cancel",
+    )
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+
+  it("userId 进 where（归属判定即存在性判定，不泄露他人 run）", async () => {
+    mocks.findFirst.mockResolvedValue({ id: "r-1", threadId: "t-1", driverEpoch: null })
+
+    await cancelRunFn({ data: { threadId: "t-1" } })
+
+    expect(mocks.findFirst).toHaveBeenCalledWith({
+      where: {
+        threadId: "t-1",
+        userId: "user-1",
+        status: { in: ["running", "interrupted"] },
+      },
+      select: { id: true, threadId: true, driverEpoch: true },
+    })
+  })
+
+  it("只定位 running / interrupted，terminal run 不会被误 cancel", async () => {
+    mocks.findFirst.mockResolvedValue({ id: "r-1", threadId: "t-1", driverEpoch: null })
+    await cancelRunFn({ data: { threadId: "t-1" } })
+
+    const where = mocks.findFirst.mock.calls[0][0].where as {
+      status: { in: string[] }
+    }
+    expect(where.status.in).toEqual(["running", "interrupted"])
+  })
+
+  it("显式传 runId 时限定到该 run，避免误伤同一线程的下一轮 run", async () => {
+    mocks.findFirst.mockResolvedValue({ id: "r-9", threadId: "t-1", driverEpoch: null })
+
+    await cancelRunFn({ data: { threadId: "t-1", runId: "r-9" } })
+
+    expect(mocks.findFirst.mock.calls[0][0].where).toMatchObject({ id: "r-9" })
+  })
+
+  it("driverEpoch 为 null 时从 1 起写，并落 cancelRequested + detachedSince", async () => {
+    mocks.findFirst.mockResolvedValue({ id: "r-1", threadId: "t-1", driverEpoch: null })
+
+    await expect(
+      cancelRunFn({ data: { threadId: "t-1" } }),
+    ).resolves.toEqual({ ok: true, runId: "r-1", threadId: "t-1" })
+
+    expect(mocks.update).toHaveBeenCalledWith(
+      "r-1",
+      expect.objectContaining({
+        cancelRequested: true,
+        driverEpoch: 1,
+        detachedSince: expect.any(Number),
+      }),
+    )
+  })
+
+  it("driverEpoch 已有值时递增（重复点停止不丢增量）", async () => {
+    mocks.findFirst.mockResolvedValue({ id: "r-1", threadId: "t-1", driverEpoch: 3 })
+
+    await cancelRunFn({ data: { threadId: "t-1" } })
+
+    expect(mocks.update).toHaveBeenCalledWith(
+      "r-1",
+      expect.objectContaining({ driverEpoch: 4 }),
+    )
+  })
+})

package/src/server/serverFns/harness/__tests__/gallery.spec.ts

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+
+const mocks = vi.hoisted(() => ({
+  request: new Request("https://allblue.test/gallery", { headers: { cookie: "session=test" } }),
+  auth: vi.fn(), feature: vi.fn(), resource: vi.fn(), findMany: vi.fn(), findFirst: vi.fn(), thread: vi.fn(),
+  generate: vi.fn(), video: vi.fn(), speech: vi.fn(), config: vi.fn(),
+}))
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: () => ({ validator: (schema: ZodType) => ({
+    handler: (fn: (args: { data: unknown }) => unknown) => async (args: { data: unknown }) => fn({ data: schema.parse(args.data) }),
+  }) }),
+}))
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => mocks.request }))
+vi.mock("@allbluecn/database", () => ({ prisma: {
+  generationRun: { findMany: mocks.findMany, findFirst: mocks.findFirst, findUnique: mocks.findFirst },
+  chatThread: { findFirst: mocks.thread },
+} }))
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: mocks.auth }))
+vi.mock("@/server/entitlements", () => ({ requireFeature: mocks.feature }))
+vi.mock("@/server/resources", () => ({ requireResource: mocks.resource }))
+vi.mock("@/server/ai-gateway/media", () => ({
+  generateImageForUser: mocks.generate,
+  generateVideoForUser: mocks.video,
+  generateSpeechForUser: mocks.speech,
+}))
+vi.mock("@/server/ai-gateway/provider-router", () => ({ resolveAiConfigForModel: mocks.config }))
+import { listGenerationRunsFn, createVariantFn } from "../gallery"
+
+const date = new Date("2026-09-17T00:00:00.000Z")
+const row = (id: string) => ({ id, activity: "image", kind: "image", status: "completed", provider: "openai", model: "gpt-image-1", artifacts: null, result: { images: [{ b64Json: "aGVsbG8=" }] }, usage: null, startedAt: date, threadId: "thread-1" })
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "user-1" } })
+  mocks.thread.mockResolvedValue({ id: "thread-1" })
+  mocks.findMany.mockResolvedValue([])
+  mocks.findFirst.mockResolvedValue({ ...row("source"), userId: "user-1", input: { prompt: "original" } })
+  mocks.config.mockResolvedValue({ adapterKind: "openai", apiKey: "test", model: "gpt-image-1" })
+  mocks.generate.mockResolvedValue({ runId: "new-run", artifacts: [], images: [{ b64Json: "bmV3" }] })
+})
+
+describe("gallery", () => {
+  it("passes the actual request to authentication and feature checks", async () => {
+    await listGenerationRunsFn({ data: {} })
+    expect(mocks.auth.mock.calls[0][0]).toBe(mocks.request)
+    expect(mocks.feature).toHaveBeenCalledWith(mocks.request, "mediaGeneration")
+  })
+  it("uses the last returned row and a stable id tie breaker without overriding date filters", async () => {
+    mocks.findMany.mockResolvedValueOnce([row("c"), row("b"), row("a")])
+    const page = await listGenerationRunsFn({ data: { limit: 2 } })
+    expect(page.runs.map(r => r.id)).toEqual(["c", "b"])
+    expect(JSON.parse(page.nextCursor!)).toEqual({ startedAt: date.toISOString(), id: "b" })
+    await listGenerationRunsFn({ data: { limit: 2, cursor: page.nextCursor!, startedAtGte: "2026-09-01", startedAtLte: "2026-09-30" } })
+    expect(mocks.findMany.mock.calls[1][0]).toMatchObject({
+      where: { userId: "user-1", startedAt: { gte: new Date("2026-09-01"), lte: new Date("2026-09-30") }, OR: [{ startedAt: { lt: date } }, { startedAt: date, id: { lt: "b" } }] },
+      orderBy: [{ startedAt: "desc" }, { id: "desc" }],
+    })
+  })
+  it.each([0, -1, 1.5, 101])("rejects invalid limit %s", async limit => {
+    await expect(listGenerationRunsFn({ data: { limit } })).rejects.toThrow()
+  })
+  it("rejects malformed dates and cursors", async () => {
+    await expect(listGenerationRunsFn({ data: { startedAtGte: "bad" } })).rejects.toThrow()
+    await expect(listGenerationRunsFn({ data: { cursor: "bad" } })).rejects.toThrow()
+  })
+  it("normalizes official tts activity to speech", async () => {
+    mocks.findMany.mockResolvedValue([{ ...row("tts"), activity: "tts" }])
+    const page = await listGenerationRunsFn({ data: { kind: "speech" } })
+    expect(mocks.findMany.mock.calls[0][0].where.activity).toBe("tts")
+    expect(page.runs[0].kind).toBe("speech")
+  })
+  it("generates an image variant from the owned source image and saved prompt", async () => {
+    const result = await createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })
+    expect(mocks.findFirst.mock.calls[0][0].where).toMatchObject({ id: "source", userId: "user-1" })
+    expect(mocks.thread).toHaveBeenCalledWith({ where: { id: "thread-1", userId: "user-1" }, select: { id: true } })
+    expect(mocks.generate).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-1", threadId: "thread-1", prompt: "original", referenceImage: "data:image/png;base64,aGVsbG8=", sourceRunId: "source" }))
+    expect(result).toMatchObject({ runId: "new-run", images: [{ b64Json: "bmV3" }] })
+  })
+  it("regenerates a video variant from the same prompt", async () => {
+    mocks.findFirst.mockResolvedValue({ ...row("source"), activity: "video", input: { prompt: "film again" } })
+    mocks.video.mockResolvedValue({ runId: "new-run", jobId: "video-job", model: "video-1", artifacts: [] })
+    const result = await createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })
+    expect(mocks.video).toHaveBeenCalledWith(expect.objectContaining({ prompt: "film again", threadId: "thread-1", userId: "user-1" }))
+    expect(mocks.generate).not.toHaveBeenCalled()
+    expect(result).toMatchObject({ runId: "new-run", jobId: "video-job" })
+  })
+  it("regenerates a speech variant from the same text", async () => {
+    mocks.findFirst.mockResolvedValue({ ...row("source"), activity: "tts", input: { text: "speak again" } })
+    mocks.speech.mockResolvedValue({ runId: "new-run", id: "speech-1", model: "tts-1", audio: "bmV3", format: "mp3", artifacts: [] })
+    const result = await createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })
+    expect(mocks.speech).toHaveBeenCalledWith(expect.objectContaining({ text: "speak again", threadId: "thread-1", userId: "user-1" }))
+    expect(mocks.generate).not.toHaveBeenCalled()
+    expect(mocks.video).not.toHaveBeenCalled()
+    expect(result).toMatchObject({ runId: "new-run", id: "speech-1" })
+  })
+  it("rejects prototype source as variant", async () => {
+    mocks.findFirst.mockResolvedValue({ ...row("source"), activity: "prototype", kind: "prototype" })
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow("cannot be regenerated as variants")
+    expect(mocks.generate).not.toHaveBeenCalled()
+  })
+  it("rejects transcription source as variant", async () => {
+    mocks.findFirst.mockResolvedValue({ ...row("source"), activity: "transcription" })
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow("does not support variants")
+    expect(mocks.generate).not.toHaveBeenCalled()
+  })
+  it("rejects missing or foreign source without generation", async () => {
+    mocks.findFirst.mockResolvedValue(null)
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow()
+    expect(mocks.generate).not.toHaveBeenCalled()
+  })
+  it("rejects foreign destination thread", async () => {
+    mocks.thread.mockResolvedValue(null)
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow()
+    expect(mocks.generate).not.toHaveBeenCalled()
+  })
+  it.each(["transcription", "chat"])("rejects unsupported source %s", async activity => {
+    mocks.findFirst.mockResolvedValue({ ...row("source"), activity })
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow()
+    expect(mocks.generate).not.toHaveBeenCalled()
+  })
+  it("propagates generation failure instead of claiming success", async () => {
+    mocks.generate.mockRejectedValue(new Error("provider failed"))
+    await expect(createVariantFn({ data: { sourceRunId: "source", threadId: "thread-1" } })).rejects.toThrow("provider failed")
+  })
+})