@allbluecn/web-app 0.12.0 → 0.12.3

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

@@ -0,0 +1,67 @@
+import { beforeEach, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+const mocks = vi.hoisted(() => ({
+  request: new Request("https://allblue.test/media"),
+  auth: vi.fn(),
+  feature: vi.fn(),
+  resource: vi.fn(),
+  thread: vi.fn(),
+  agent: vi.fn(),
+  record: 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/resources", () => ({ requireResource: mocks.resource }))
+vi.mock("@allbluecn/database", () => ({
+  prisma: { chatThread: { findFirst: mocks.thread } },
+}))
+vi.mock("@/server/ai-gateway/runs/agent-runtime", () => ({ runChatAsAgent: mocks.agent }))
+vi.mock("@/server/ai-gateway/media/recorder", () => ({ recordGenerationRun: mocks.record }))
+import { generatePrototypeFn } from "../media"
+import { prototypeSchema, stripCodeFence } from "@/server/ai-gateway/media/prototype-schema.ts"
+
+const validPayload = {
+  message: "原型",
+  components: [
+    { type: "button", source: "builtin" as const, name: "按钮" },
+    { type: "card", source: "custom" as const, name: "卡片" },
+  ],
+}
+
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "owner" } })
+  mocks.thread.mockResolvedValue({ id: "thread" })
+  mocks.record.mockResolvedValue({ id: "run-1" })
+})
+
+it("generatePrototypeFn：runChatAsAgent 生成 + recordGenerationRun 落库 + 不挂 requireResource", async () => {
+  const fenced = "```json\n" + JSON.stringify(validPayload) + "\n```"
+  mocks.agent.mockResolvedValue(fenced)
+  const res = await generatePrototypeFn({ data: { prompt: "做一个登录页", threadId: "thread" } })
+  expect(mocks.feature).toHaveBeenCalledTimes(1)
+  expect(mocks.resource).not.toHaveBeenCalled()
+  const recorded = mocks.record.mock.calls[0][0]
+  expect(recorded).toMatchObject({
+    userId: "owner", threadId: "thread", activity: "prototype", status: "completed",
+  })
+  expect(mocks.thread).toHaveBeenCalledTimes(1)
+  expect(stripCodeFence(fenced)).toBe(JSON.stringify(validPayload))
+  expect(prototypeSchema.parse(JSON.parse(stripCodeFence(fenced)))).toEqual(validPayload)
+  expect(Array.isArray(recorded.result.components) && recorded.result.components.length > 0).toBe(true)
+  expect(res).toMatchObject({ runId: "run-1", result: { message: "原型" } })
+})
+
+it("generatePrototypeFn：runChatAsAgent 返回非法 JSON → 抛错且不落库", async () => {
+  mocks.agent.mockResolvedValue("not-json")
+  await expect(generatePrototypeFn({ data: { prompt: "x", threadId: "thread" } })).rejects.toThrow()
+  expect(mocks.record).not.toHaveBeenCalled()
+})

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

@@ -0,0 +1,43 @@
+import { beforeEach, expect, it, vi } from "vitest"
+import type { ZodType } from "zod"
+const mocks = vi.hoisted(() => ({ request: new Request("https://allblue.test/media"), auth: vi.fn(), feature: vi.fn(), resource: vi.fn(), config: vi.fn(), generate: vi.fn(), thread: 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/resources", () => ({ requireResource: mocks.resource }))
+vi.mock("@/server/ai-gateway/adapter", () => ({ resolveAiConfig: mocks.config }))
+vi.mock("@allbluecn/database", () => ({ prisma: { chatThread: { findFirst: mocks.thread } } }))
+vi.mock("@/server/ai-gateway/media", () => ({ generateImageForUser: mocks.generate, generateVideoForUser: mocks.generate, pollVideoForUser: mocks.generate, generateSpeechForUser: mocks.generate, generateTranscriptionForUser: mocks.generate }))
+import { generateImageFn, startVideoFn, pollVideoFn, generateSpeechFn, generateTranscriptionFn } from "../media"
+beforeEach(() => {
+  vi.resetAllMocks()
+  mocks.auth.mockResolvedValue({ user: { id: "owner" } })
+  mocks.thread.mockResolvedValue({ id: "thread" })
+  mocks.config.mockResolvedValue({ provider: "openai", apiKey: "test", model: "gpt-image-1" })
+  mocks.generate.mockResolvedValue({ runId: "run", images: [], artifacts: [], jobId: "job", text: "text" })
+})
+const calls = [
+  () => generateImageFn({ data: { prompt: "paint", threadId: "thread" } }),
+  () => startVideoFn({ data: { prompt: "film", threadId: "thread" } }),
+  () => pollVideoFn({ data: { jobId: "job", threadId: "thread" } }),
+  () => generateSpeechFn({ data: { text: "speak", threadId: "thread" } }),
+  () => generateTranscriptionFn({ data: { audio: "YQ==", threadId: "thread" } }),
+]
+it.each(calls.map((call, index) => ({ call, index })))("passes actual request for entry $index", async ({ call }) => {
+  await call()
+  expect(mocks.auth.mock.calls[0][0]).toBe(mocks.request)
+  expect(mocks.feature.mock.calls[0][0]).toBe(mocks.request)
+})
+it.each(calls.map((call, index) => ({ call, index })))("rejects foreign thread for entry $index before provider", async ({ call }) => {
+  mocks.thread.mockResolvedValue(null)
+  await expect(call()).rejects.toThrow("Thread not found")
+  expect(mocks.generate).not.toHaveBeenCalled()
+})
+it("does not charge generation quota again when polling", async () => {
+  await calls[2]()
+  expect(mocks.resource).not.toHaveBeenCalled()
+})
+it("returns the persisted image run id", async () => {
+  expect(await calls[0]()).toMatchObject({ runId: "run", artifacts: [], images: [] })
+})

package/src/server/serverFns/harness/__tests__/sandbox-policy.test.ts

@@ -0,0 +1,199 @@
+// @vitest-environment node
+
+// 沙箱策略 serverFn 归属与确认矩阵：GET 回落默认档、POST 拒绝非法档与
+// 未确认的 full 档、越权访问统一 Unauthorized。mock 骨架与
+// workspace-kb-idor.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 findUnique = vi.fn()
+  const update = vi.fn()
+  const getCurrentSession = vi.fn()
+  const assertSandboxEntitled = vi.fn()
+  return { findUnique, update, getCurrentSession, assertSandboxEntitled }
+})
+
+vi.mock("@/server/ai-gateway/sandbox/entitlement", () => ({
+  assertSandboxEntitled: (...args: unknown[]) => mocks.assertSandboxEntitled(...args),
+}))
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    chatThread: {
+      findUnique: mocks.findUnique,
+      update: mocks.update,
+    },
+  },
+}))
+vi.mock("@/lib/session", () => ({
+  getCurrentSession: mocks.getCurrentSession,
+}))
+
+import { getSandboxPolicyFn, setSandboxPolicyFn } from "../sandbox-policy"
+
+const OWNER = { id: "user-1", name: "owner", email: "owner@example.com" }
+
+describe("getSandboxPolicyFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.getCurrentSession.mockResolvedValue({ user: OWNER })
+  })
+
+  it("归属线程返回 DB 持久化的策略档", async () => {
+    mocks.findUnique.mockResolvedValue({
+      id: "t-1",
+      userId: "user-1",
+      sandboxPolicy: "workspace-write",
+    })
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-1" } })).resolves.toBe(
+      "workspace-write",
+    )
+  })
+
+  it("DB 值非法时回落默认 readonly（fail-closed，不返回更宽的档）", async () => {
+    mocks.findUnique.mockResolvedValue({
+      id: "t-1",
+      userId: "user-1",
+      sandboxPolicy: "admin",
+    })
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-1" } })).resolves.toBe("readonly")
+  })
+
+  it("DB 值为 null（历史线程未初始化）时回落默认 readonly", async () => {
+    mocks.findUnique.mockResolvedValue({ id: "t-1", userId: "user-1", sandboxPolicy: null })
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-1" } })).resolves.toBe("readonly")
+  })
+
+  it("未登录拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue(null)
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-1" } })).rejects.toThrow("Unauthorized")
+  })
+
+  it("线程不存在时拒绝且不泄露归属信息", async () => {
+    mocks.findUnique.mockResolvedValue(null)
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-404" } })).rejects.toThrow(
+      "Chat thread not found: t-404",
+    )
+  })
+
+  it("他人线程拒绝（IDOR）", async () => {
+    mocks.findUnique.mockResolvedValue({ id: "t-1", userId: "user-2", sandboxPolicy: "full" })
+    await expect(getSandboxPolicyFn({ data: { threadId: "t-1" } })).rejects.toThrow("Unauthorized")
+  })
+})
+
+describe("setSandboxPolicyFn", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.assertSandboxEntitled.mockReset().mockResolvedValue(undefined)
+    mocks.getCurrentSession.mockResolvedValue({ user: OWNER })
+    mocks.findUnique.mockResolvedValue({
+      id: "t-1",
+      userId: "user-1",
+      sandboxPolicy: "readonly",
+    })
+    mocks.update.mockImplementation(({ data: payload }: { data: { sandboxPolicy: string } }) =>
+      Promise.resolve({ sandboxPolicy: payload.sandboxPolicy }),
+    )
+  })
+
+  it("沙箱计费闸门先于写库执行（权益未开通用户无法改策略）", async () => {
+    mocks.assertSandboxEntitled.mockRejectedValue(
+      new Error("Feature is not enabled: sandboxExecution"),
+    )
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "workspace-write" } }),
+    ).rejects.toThrow("Feature is not enabled: sandboxExecution")
+    expect(mocks.assertSandboxEntitled).toHaveBeenCalledTimes(1)
+    expect(mocks.findUnique).not.toHaveBeenCalled()
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+
+  it("readonly / workspace-write 直接写入并返回新档", async () => {
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "workspace-write" } }),
+    ).resolves.toBe("workspace-write")
+    expect(mocks.update).toHaveBeenCalledWith({
+      where: { id: "t-1" },
+      data: { sandboxPolicy: "workspace-write" },
+      select: { sandboxPolicy: true },
+    })
+  })
+
+  it("非法档拒绝且不触达数据库", async () => {
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "admin" } }),
+    ).rejects.toThrow("Invalid sandbox policy level: admin")
+    expect(mocks.findUnique).not.toHaveBeenCalled()
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+
+  it("full 档缺 confirmFull 时拒绝（安全边界在服务端而非 UI 弹窗）", async () => {
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "full" } }),
+    ).rejects.toThrow("Enabling full sandbox policy requires confirmFull")
+    expect(mocks.findUnique).not.toHaveBeenCalled()
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+
+  it("full 档携带 confirmFull 时放行", async () => {
+    await expect(
+      setSandboxPolicyFn({
+        data: { threadId: "t-1", level: "full", confirmFull: true },
+      }),
+    ).resolves.toBe("full")
+    expect(mocks.update).toHaveBeenCalledTimes(1)
+  })
+
+  it("空 confirmFull 经 validator 默认 false，仍触发 full 确认拦截", async () => {
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "full", confirmFull: undefined } }),
+    ).rejects.toThrow("Enabling full sandbox policy requires confirmFull")
+  })
+
+  it("他人线程拒绝且零写入", async () => {
+    mocks.findUnique.mockResolvedValue({ id: "t-1", userId: "user-2", sandboxPolicy: "readonly" })
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "full", confirmFull: true } }),
+    ).rejects.toThrow("Unauthorized")
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+
+  it("未登录拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue(null)
+    await expect(
+      setSandboxPolicyFn({ data: { threadId: "t-1", level: "full", confirmFull: true } }),
+    ).rejects.toThrow("Unauthorized")
+    expect(mocks.update).not.toHaveBeenCalled()
+  })
+})

package/src/server/serverFns/harness/__tests__/workspace-files.test.ts

@@ -0,0 +1,224 @@
+// @vitest-environment node
+
+// 云端工作区文件 serverFn 归属校验与 IDOR 防护测试。
+// 核心场景：非 owner 访问他人工作区的文件时 findFirst 含 ownerId 过滤，拒绝且不触达下游查询。
+// mock 骨架参照 sandbox-policy.test.ts / cancel-run.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 harnessWorkspaceFindFirst = vi.fn()
+  const harnessWorkspaceFindMany = vi.fn()
+  const harnessWorkspaceCreate = vi.fn()
+  const workspaceFileFindMany = vi.fn()
+  const workspaceFileUpsert = vi.fn()
+  const workspaceFileDelete = vi.fn()
+  const workspaceFileFindFirst = vi.fn()
+  const getCurrentSession = vi.fn()
+  return {
+    harnessWorkspaceFindFirst,
+    harnessWorkspaceFindMany,
+    harnessWorkspaceCreate,
+    workspaceFileFindMany,
+    workspaceFileUpsert,
+    workspaceFileDelete,
+    workspaceFileFindFirst,
+    getCurrentSession,
+  }
+})
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    harnessWorkspace: {
+      findFirst: mocks.harnessWorkspaceFindFirst,
+      findMany: mocks.harnessWorkspaceFindMany,
+      create: mocks.harnessWorkspaceCreate,
+    },
+    workspaceFile: {
+      findMany: mocks.workspaceFileFindMany,
+      upsert: mocks.workspaceFileUpsert,
+      delete: mocks.workspaceFileDelete,
+      findFirst: mocks.workspaceFileFindFirst,
+    },
+  },
+}))
+vi.mock("@/lib/session", () => ({
+  getCurrentSession: mocks.getCurrentSession,
+}))
+
+import {
+  createHarnessWorkspaceFn,
+  listHarnessWorkspacesFn,
+  listWorkspaceFilesFn,
+  uploadWorkspaceFileFn,
+  deleteWorkspaceFileFn,
+} from "../workspace-files"
+
+const OWNER = { id: "user-owner-1", name: "owner", email: "owner@example.com" }
+const OTHER_USER = "user-attacker-2"
+const WS_ID = "ws-target-1"
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.getCurrentSession.mockResolvedValue({ user: OWNER })
+  mocks.harnessWorkspaceFindFirst.mockResolvedValue({ id: WS_ID })
+  mocks.harnessWorkspaceFindMany.mockResolvedValue([])
+  mocks.workspaceFileFindMany.mockResolvedValue([])
+  mocks.workspaceFileUpsert.mockResolvedValue({ id: "f-1", path: "test.txt" })
+  mocks.workspaceFileDelete.mockResolvedValue({ id: "f-1" })
+  mocks.workspaceFileFindFirst.mockResolvedValue({ id: "f-1" })
+  mocks.harnessWorkspaceCreate.mockResolvedValue({ id: "ws-1", name: "test" })
+})
+
+describe("createHarnessWorkspaceFn", () => {
+  it("未登录拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue(null)
+    await expect(
+      createHarnessWorkspaceFn({ data: { name: "my-workspace" } }),
+    ).rejects.toThrow("Unauthorized")
+    expect(mocks.harnessWorkspaceCreate).not.toHaveBeenCalled()
+  })
+
+  it("正常创建返回 id 和 name", async () => {
+    const result = await createHarnessWorkspaceFn({ data: { name: "my-workspace" } })
+    expect(result).toEqual({ id: "ws-1", name: "test" })
+    expect(mocks.harnessWorkspaceCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ ownerId: OWNER.id, name: "my-workspace" }),
+      }),
+    )
+  })
+})
+
+describe("listHarnessWorkspacesFn", () => {
+  it("未登录拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue(null)
+    await expect(listHarnessWorkspacesFn({ data: undefined })).rejects.toThrow("Unauthorized")
+    expect(mocks.harnessWorkspaceFindMany).not.toHaveBeenCalled()
+  })
+
+  it("返回 owner 的工作区列表（按 updatedAt 倒序）", async () => {
+    mocks.harnessWorkspaceFindMany.mockResolvedValue([
+      { id: "ws-1", name: "a", kind: "cloud", updatedAt: new Date(), _count: { files: 2 } },
+    ])
+    const result = await listHarnessWorkspacesFn({ data: undefined })
+    expect(result).toHaveLength(1)
+    expect(mocks.harnessWorkspaceFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { ownerId: OWNER.id },
+      }),
+    )
+  })
+})
+
+describe("listWorkspaceFilesFn 归属校验", () => {
+  it("非 owner 访问他人工作区 → findFirst where 含 ownerId 过滤", async () => {
+    mocks.getCurrentSession.mockResolvedValue({ user: { id: OTHER_USER } })
+    mocks.harnessWorkspaceFindFirst.mockResolvedValue(null)
+
+    await expect(
+      listWorkspaceFilesFn({ data: { workspaceId: WS_ID } }),
+    ).rejects.toThrow("工作区不存在或无权访问")
+
+    expect(mocks.harnessWorkspaceFindFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ ownerId: OTHER_USER }),
+      }),
+    )
+    // 归属校验失败，不得触达下游文件查询
+    expect(mocks.workspaceFileFindMany).not.toHaveBeenCalled()
+  })
+
+  it("owner 访问自己的工作区 → 返回文件列表", async () => {
+    mocks.harnessWorkspaceFindFirst.mockResolvedValue({ id: WS_ID })
+    mocks.workspaceFileFindMany.mockResolvedValue([
+      { id: "f-1", path: "src/index.ts", mimeType: "text/typescript", size: 100, source: "upload", updatedAt: new Date() },
+    ])
+    const result = await listWorkspaceFilesFn({ data: { workspaceId: WS_ID } })
+    expect(result).toHaveLength(1)
+    expect(result[0].path).toBe("src/index.ts")
+  })
+
+  it("workspaceId 为空串经 validator 拒绝", async () => {
+    await expect(listWorkspaceFilesFn({ data: { workspaceId: "" } })).rejects.toThrow()
+    expect(mocks.harnessWorkspaceFindFirst).not.toHaveBeenCalled()
+  })
+})
+
+describe("uploadWorkspaceFileFn 归属校验", () => {
+  it("非 owner 上传 → 归属校验失败，不写入 DB", async () => {
+    mocks.getCurrentSession.mockResolvedValue({ user: { id: OTHER_USER } })
+    mocks.harnessWorkspaceFindFirst.mockResolvedValue(null)
+
+    await expect(
+      uploadWorkspaceFileFn({
+        data: { workspaceId: WS_ID, path: "evil.txt", content: "malicious" },
+      }),
+    ).rejects.toThrow("工作区不存在或无权访问")
+
+    expect(mocks.workspaceFileUpsert).not.toHaveBeenCalled()
+  })
+
+  it("owner 正常上传 → upsert 落库", async () => {
+    mocks.workspaceFileUpsert.mockResolvedValue({ id: "f-1", path: "src/main.ts" })
+    const result = await uploadWorkspaceFileFn({
+      data: { workspaceId: WS_ID, path: "src/main.ts", content: "export default {}", mimeType: "text/typescript" },
+    })
+    expect(result).toEqual({ id: "f-1", path: "src/main.ts" })
+    expect(mocks.workspaceFileUpsert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { workspaceId_path: { workspaceId: WS_ID, path: "src/main.ts" } },
+      }),
+    )
+  })
+})
+
+describe("deleteWorkspaceFileFn 归属校验", () => {
+  it("非 owner 删除他人文件 → findFirst via workspace.ownerId 拒绝", async () => {
+    mocks.getCurrentSession.mockResolvedValue({ user: { id: OTHER_USER } })
+    mocks.workspaceFileFindFirst.mockResolvedValue(null)
+
+    await expect(
+      deleteWorkspaceFileFn({ data: { fileId: "f-99" } }),
+    ).rejects.toThrow("文件不存在或无权访问")
+
+    // 归属校验失败时不执行 delete
+    expect(mocks.workspaceFileDelete).not.toHaveBeenCalled()
+  })
+
+  it("owner 删除自己的文件 → 正常删除", async () => {
+    mocks.workspaceFileDelete.mockResolvedValue({ id: "f-1" })
+    const result = await deleteWorkspaceFileFn({ data: { fileId: "f-1" } })
+    expect(result).toEqual({ id: "f-1" })
+    expect(mocks.workspaceFileDelete).toHaveBeenCalledWith({ where: { id: "f-1" } })
+  })
+})

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

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+
+import { prisma } from "@allbluecn/database"
+
+/** P4d 回流守卫（ADR 34）：源 GenerationRun 与目标实体归属校验，非本人一律按 not found 拒绝（不泄露存在性）。 */
+
+export async function assertRunOwnership(generationRunId: string, userId: string) {
+  const run = await prisma.generationRun.findFirst({ where: { id: generationRunId, userId } })
+  if (!run) throw new Error("Generation run not found")
+  return run
+}
+
+export async function assertStoryOwnership(storyId: string, userId: string) {
+  const story = await prisma.story.findFirst({ where: { id: storyId, project: { ownerId: userId } } })
+  if (!story) throw new Error("Story not found")
+  return story
+}
+
+export async function assertKbOwnership(kbId: string, userId: string) {
+  const kb = await prisma.knowledgeBase.findFirst({ where: { id: kbId, userId, isDeleted: false } })
+  if (!kb) throw new Error("Knowledge base not found")
+  return kb
+}
+
+export async function assertPrdOwnership(prdId: string, userId: string) {
+  const prd = await prisma.pRD.findFirst({ where: { id: prdId, userId } })
+  if (!prd) throw new Error("PRD not found")
+  return prd
+}

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

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+
+import { createServerFn } from "@tanstack/react-start"
+import { getRequest } from "@tanstack/react-start/server"
+import { z } from "zod"
+import { prisma, Prisma } from "@allbluecn/database"
+import { requireAuth } from "@/server/auth-helpers"
+import { requireFeature } from "@/server/entitlements"
+import { assertRunOwnership, assertPrdOwnership } from "./attach-guards"
+
+/**
+ * 回流→PRD 原型（P4d 转正，ADR 37）。
+ * 无独立 prototype 表：GenerationRun.result 的组件树（generatePrototypeFn 的
+ * prototypeSchema shape）写入 prdId 首个 PRDPage.canvas（对齐 updatePrdPageFn 语义）。
+ * 成功后写 GenerationRun.linkedTarget（覆盖）。
+ */
+
+const AttachPrototypeToPrdSchema = z.object({
+  generationRunId: z.string().min(1),
+  prdId: z.string().min(1),
+})
+
+const prototypeResultSchema = z.object({
+  message: z.string().optional(),
+  components: z.array(z.object({
+    type: z.string(),
+    source: z.enum(["builtin", "custom"]),
+    name: z.string(),
+    props: z.record(z.string(), z.json()).optional(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+  })).min(1),
+})
+
+export const attachPrototypeToPrdFn = createServerFn({ method: "POST" })
+  .validator(AttachPrototypeToPrdSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    await requireFeature(request, "mediaGeneration")
+    const session = await requireAuth(request)
+    const userId = session.user!.id!
+
+    const run = await assertRunOwnership(data.generationRunId, userId)
+    await assertPrdOwnership(data.prdId, userId)
+
+    const proto = prototypeResultSchema.safeParse(run.result)
+    if (!proto.success) throw new Error("Generation run has no prototype components")
+    // 清洗 undefined 键（zod .optional() 保留 undefined），避免静默存 null 进 JSON 字段
+    const canvas = JSON.parse(JSON.stringify(proto.data))
+
+    const page = await prisma.pRDPage.findFirst({
+      where: { prdId: data.prdId },
+      orderBy: { order: "asc" },
+    })
+    if (!page) throw new Error("PRD has no page")
+
+    await prisma.pRDPage.update({ where: { id: page.id }, data: { canvas: canvas as Prisma.InputJsonValue } })
+    const linkedTarget = { kind: "prd", targetId: data.prdId, at: new Date().toISOString() }
+    await prisma.generationRun.update({ where: { id: run.id }, data: { linkedTarget } })
+    return { pageId: page.id, canvas, linkedTarget }
+  })