@allbluecn/web-app 0.12.0 → 0.12.2

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

@@ -0,0 +1,80 @@
+// 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 } from "@allbluecn/database"
+import { requireAuth } from "@/server/auth-helpers"
+import { requireFeature } from "@/server/entitlements"
+import { indexDocumentById } from "@/server/ai-gateway/knowledge-index-core"
+import { assertKbOwnership, assertRunOwnership } from "./attach-guards"
+
+/**
+ * 回流→KB 文档（P4d，spec §3.2）。三步写入：create 骨架（对齐 createDocumentFn 语义）
+ * → update content（生成物正文）→ indexDocumentById 向量索引（fire-and-forget，对齐
+ * knowledge.ts:325-333 的容错语义）。投毒防护在检索侧 buildGuardedKbContext（既有），
+ * 写侧无围栏。成功后写 GenerationRun.linkedTarget（覆盖）。
+ */
+
+const AttachToKbSchema = z.object({
+  generationRunId: z.string().min(1),
+  kbId: z.string().min(1),
+  title: z.string().trim().min(1).max(100),
+})
+
+function extractText(result: unknown): string | undefined {
+  const r = z.object({
+    text: z.string().optional(),
+    prompt: z.string().optional(),
+    markdown: z.string().optional(),
+  }).safeParse(result)
+  if (!r.success) return undefined
+  return r.data.text ?? r.data.markdown ?? r.data.prompt
+}
+
+export const attachToKbFn = createServerFn({ method: "POST" })
+  .validator(AttachToKbSchema)
+  .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 assertKbOwnership(data.kbId, userId)
+
+    const text = extractText(run.result)
+    if (!text?.trim()) throw new Error("Generation run has no extractable text")
+
+    const maxSort = await prisma.knowledgeDocument.aggregate({
+      where: { kbId: data.kbId, parentId: null, isDeleted: false },
+      _max: { sortOrder: true },
+    })
+    const doc = await prisma.knowledgeDocument.create({
+      data: {
+        kbId: data.kbId,
+        parentId: null,
+        title: data.title,
+        type: "doc",
+        sortOrder: (maxSort._max.sortOrder ?? -1) + 1,
+        properties: {},
+        createdBy: userId,
+      },
+      select: { id: true },
+    })
+    await prisma.knowledgeDocument.update({
+      where: { id: doc.id },
+      data: { content: { markdown: text } },
+    })
+
+    // fire-and-forget：索引失败不阻塞回流（对齐 knowledge.ts:325-333），不能静默
+    void indexDocumentById(doc.id).catch((e: unknown) => {
+      console.warn(`[attach-kb] 向量索引失败 documentId=${doc.id}: ${e instanceof Error ? e.message : String(e)}`)
+    })
+
+    const linkedTarget = { kind: "kb", targetId: data.kbId, at: new Date().toISOString() }
+    await prisma.generationRun.update({ where: { id: run.id }, data: { linkedTarget } })
+    return { documentId: doc.id, linkedTarget }
+  })

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

@@ -0,0 +1,74 @@
+// 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 } from "@allbluecn/database"
+import { requireAuth } from "@/server/auth-helpers"
+import { requireFeature } from "@/server/entitlements"
+import { assertFetchableUrl } from "@/server/fetch-guard"
+import { assertRunOwnership, assertStoryOwnership } from "./attach-guards"
+
+/**
+ * 回流→故事附件（P4d，spec §3.2）。
+ * GenerationRun.artifacts（PersistedArtifactRef[].url）fetch 字节流 →
+ * StoryAttachment 两段式落库（语义对齐 routes/api/attachments/upload.ts:100-116）。
+ * 首个 artifact 为准；成功后写 GenerationRun.linkedTarget（覆盖语义，ADR 38）。
+ */
+
+const AttachToStorySchema = z.object({
+  generationRunId: z.string().min(1),
+  storyId: z.string().min(1),
+})
+
+// 对齐 routes/api/attachments/upload.ts MAX_FILE_SIZE（10 MB）
+const MAX_ARTIFACT_BYTES = 10 * 1024 * 1024
+
+export const attachToStoryFn = createServerFn({ method: "POST" })
+  .validator(AttachToStorySchema)
+  .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 assertStoryOwnership(data.storyId, userId)
+
+    const artifacts = z.array(z.object({
+      url: z.string().optional(),
+      name: z.string().optional(),
+      mimeType: z.string().optional(),
+    })).safeParse(run.artifacts ?? [])
+    const artifact = artifacts.success ? artifacts.data.find((a) => a.url) : undefined
+    if (!artifact?.url) throw new Error("Generation run has no attachable artifact")
+
+    assertFetchableUrl(artifact.url)
+    const resp = await fetch(artifact.url)
+    if (!resp.ok) throw new Error(`Failed to download artifact: HTTP ${resp.status}`)
+    const contentLength = Number(resp.headers.get("content-length") ?? 0)
+    if (contentLength > MAX_ARTIFACT_BYTES) throw new Error("Artifact too large")
+    const buf = await resp.arrayBuffer()
+    if (buf.byteLength > MAX_ARTIFACT_BYTES) throw new Error("Artifact too large")
+    const bytes = new Uint8Array(buf)
+
+    const attachment = await prisma.storyAttachment.create({
+      data: {
+        storyId: data.storyId,
+        fileName: (artifact.name ?? "artifact").slice(0, 255),
+        fileSize: BigInt(bytes.byteLength),
+        mimeType: artifact.mimeType ?? "application/octet-stream",
+        storageUrl: "pending",
+        bytes,
+      },
+      select: { id: true },
+    })
+    const storageUrl = `/api/attachments/${attachment.id}/content`
+    await prisma.storyAttachment.update({ where: { id: attachment.id }, data: { storageUrl } })
+
+    const linkedTarget = { kind: "story", targetId: data.storyId, at: new Date().toISOString() }
+    await prisma.generationRun.update({ where: { id: run.id }, data: { linkedTarget } })
+    return { attachmentId: attachment.id, storageUrl, linkedTarget }
+  })

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

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createServerFn } from "@tanstack/react-start"
+import { getRequest } from "@tanstack/react-start/server"
+import { z } from "zod"
+import { getCurrentSession } from "@/lib/session"
+import { chatRunStore } from "@/server/ai-gateway/persistence/run-store"
+
+const cancelRunInput = z.object({
+  threadId: z.string().min(1),
+  runId: z.string().min(1).optional(),
+})
+
+/**
+ * 停止一个正在跑（或挂起等审批）的 run。
+ *
+ * 双通道语义：服务端写 `cancelRequested` 让持有该 run 的 driver/reaper 观察到
+ * 取消意图，同时递增 `driverEpoch` 让旧 driver 的 claim 失效；客户端另调
+ * `chat.stop()` 中断自己的 SSE 连接。两条通道彼此独立——只写 DB 时断线的用户
+ * 已经看不到进度，只断 SSE 时 run 会在服务端继续烧 token。
+ *
+ * `threadId` 必填、`runId` 可选：一个 thread 至多一个 active run
+ * （`findActiveRun` 的既有不变式），UI 侧当前不知道服务端铸造的 runId，故以
+ * threadId 定位；传了 runId 则限定到那一个 run，避免「点停止」误伤刚新建的
+ * 下一轮 run。归属校验走 where 条件而非事后判断——`userId` 进 where，他人
+ * run 查不到即「不存在」，不泄露跨用户 run id 的存在性。
+ *
+ * 刻意不过计费闸（任务 8 决策）：取消是**释放**动作而非消耗动作，且本 handler
+ * 要能停掉非沙箱的普通 chat run——若按「沙箱已启用」拦掉整个 cancel 路径，
+ * 权益锁定用户会失去停止能力（stop 按钮 500）。归属校验（userId 进 where）
+ * 已保证用户只能停自己的 run，不存在越权面。沙箱消耗的闸门在发起侧
+ * （/api/chat 的 sandbox 分支、setSandboxPolicyFn 的 assertSandboxEntitled）。
+ *
+ * 同时写 `detachedSince`：用户按停止即视为无人观看，run 进入 reclaimable
+ * 列表，reaper 到期后 finalize 并回收沙箱。不写这一列会让沙箱一直挂着直到
+ * provider 侧空闲回收——reaper 存在的全部意义就在这一步。
+ */
+export const cancelRunFn = createServerFn({ method: "POST" })
+  .validator(cancelRunInput)
+  .handler(async ({ data }) => {
+    const { prisma } = await import('@allbluecn/database')
+    const session = await getCurrentSession(getRequest())
+    if (!session?.user?.id) throw new Error("Unauthorized")
+    const userId = session.user.id
+
+    const active = await prisma.chatRun.findFirst({
+      where: {
+        threadId: data.threadId,
+        userId,
+        ...(data.runId ? { id: data.runId } : {}),
+        status: { in: ["running", "interrupted"] },
+      },
+      select: {
+        id: true,
+        threadId: true,
+        driverEpoch: true,
+      },
+    })
+    if (!active) throw new Error("No active run to cancel")
+
+    // read-then-write 而非 Prisma `{ increment: 1 }`：后者需要把 data 强转
+    // `Prisma.ChatRunUpdateInput`（driverEpoch 声明类型是 number|null，operator
+    // 对象不在其上），与本仓「禁止 cast 掩盖类型错误」冲突。cancel 是低频用户
+    // 动作，读改写窗口内的丢失只会让 epoch 少加 1，而 epoch 的职责是「两代
+    // driver 必须不同」——同一 run 的第二次 cancel 仍会单调递增，fence 语义
+    // 不破坏。终态写入由 reaper 自己接管，不依赖这里的精确计数。
+    await chatRunStore().update(active.id, {
+      cancelRequested: true,
+      detachedSince: Date.now(),
+      driverEpoch: (active.driverEpoch ?? 0) + 1,
+    })
+
+    return { ok: true, runId: active.id, threadId: active.threadId }
+  })

package/src/server/serverFns/{ai/execute.ts → harness/extract-attachment.ts}

@@ -8,29 +8,33 @@
 // (at your option) any later version.
 //
 // This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// but WITHOUT ANY WARRANTY; without the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Affero General Public License for more details.
 //
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import { createServerFn } from '@tanstack/react-start'
-import { getRequest } from '@tanstack/react-start/server'
-import { z } from 'zod'
-import { requireAuth } from '@/server/auth-helpers'
-import { checkAiRateLimit } from '@/server/middlewares/rate-limit-server-fn'
+import { createServerFn } from "@tanstack/react-start"
+import { z } from "zod"
 
-const schema = z.object({
-  prompt: z.string().min(1).max(10000),
-  instruction: z.string().max(2000).optional(),
+const extractAttachmentSchema = z.object({
+  text: z.string().min(1),
+  filename: z.string().min(1),
 })
 
-export const executeAiFn = createServerFn({ method: 'POST' })
-  .validator(schema)
+/**
+ * 提取附件文本内容（占位实现）。
+ *
+ * 实际生产环境应接入知识库解析管线（PDF/DOCX/Markdown 等格式解析），
+ * 此处返回 stub 以保证调用方接口一致。
+ */
+export const extractAttachmentFn = createServerFn({ method: "POST" })
+  .validator(extractAttachmentSchema)
   .handler(async ({ data }) => {
-    const request = getRequest()
-    const session = await requireAuth(request)
-    await checkAiRateLimit(session.user!.id!, "execute")
-    return { content: `Mock response for: ${data.prompt.substring(0, 50)}...` }
+    // TODO: 接入真实解析管线（如 mammoth、pdf-parse、markdown-it）
+    return {
+      extracted: data.text.slice(0, 500),
+      filename: data.filename,
+    }
   })

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

@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createServerFn } from "@tanstack/react-start"
+import { getRequest } from "@tanstack/react-start/server"
+import { generateImageForUser, generateVideoForUser, generateSpeechForUser } from "@/server/ai-gateway/media"
+import { resolveAiConfigForModel } from "@/server/ai-gateway/provider-router"
+import { z } from "zod"
+import { prisma } from "@allbluecn/database"
+import { requireAuth } from "@/server/auth-helpers"
+import { requireFeature } from "@/server/entitlements"
+import { requireResource } from "@/server/resources"
+
+/**
+ * 画廊数据源 serverFn（P4c 段二）。
+ *
+ * 按 userId 查 generation_runs 表，分页 + 筛选。
+ * artifacts 字段含 PersistedArtifactRef[]（媒体 url），画廊取回渲染。
+ */
+
+const DateSchema = z.string().refine((value) => Number.isFinite(Date.parse(value)))
+const CursorSchema = z.object({ startedAt: z.iso.datetime(), id: z.string().min(1) })
+const LinkedTargetSchema = z.object({
+  kind: z.enum(["story", "kb", "prd"]),
+  targetId: z.string().min(1),
+  at: z.string().min(1),
+})
+const ListGenerationRunsSchema = z.object({
+  kind: z.enum(["image", "video", "speech", "transcription", "prototype"]).optional(),
+  threadId: z.string().min(1).optional(),
+  startedAtGte: DateSchema.optional(),
+  startedAtLte: DateSchema.optional(),
+  cursor: z.string().transform((value) => CursorSchema.parse(JSON.parse(value))).optional(),
+  limit: z.number().int().min(1).max(100).default(20),
+}).refine((data) => !data.startedAtGte || !data.startedAtLte || Date.parse(data.startedAtGte) <= Date.parse(data.startedAtLte))
+
+function parseLinkedTarget(value: unknown): z.infer<typeof LinkedTargetSchema> | null {
+  const parsed = LinkedTargetSchema.safeParse(value)
+  return parsed.success ? parsed.data : null
+}
+
+export const listGenerationRunsFn = createServerFn({ method: "GET" })
+  .validator(ListGenerationRunsSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    // 读取操作降级：OSS 部署（功能未授予）静默返回空列表，避免 UI 抛错
+    try {
+      await requireFeature(request, "mediaGeneration")
+    } catch {
+      return { runs: [], nextCursor: null }
+    }
+
+    const session = await requireAuth(request)
+    if (!session?.user?.id) {
+      return { runs: [], nextCursor: null }
+    }
+    const userId = session.user.id
+
+    const where = {
+      userId,
+      ...(data.kind ? { activity: data.kind === "speech" ? "tts" : data.kind } : {}),
+      ...(data.threadId ? { threadId: data.threadId } : {}),
+      ...(data.startedAtGte || data.startedAtLte
+        ? {
+            startedAt: {
+              ...(data.startedAtGte ? { gte: new Date(data.startedAtGte) } : {}),
+              ...(data.startedAtLte ? { lte: new Date(data.startedAtLte) } : {}),
+            },
+          }
+        : {}),
+      ...(data.cursor ? { OR: [
+        { startedAt: { lt: new Date(data.cursor.startedAt) } },
+        { startedAt: new Date(data.cursor.startedAt), id: { lt: data.cursor.id } },
+      ] } : {}),
+    }
+
+    const runs = await prisma.generationRun.findMany({
+      where,
+      orderBy: [{ startedAt: "desc" }, { id: "desc" }],
+      take: data.limit + 1,
+      select: {
+        id: true,
+        activity: true,
+        kind: true,
+        status: true,
+        provider: true,
+        model: true,
+        artifacts: true,
+        result: true,
+        usage: true,
+        startedAt: true,
+        threadId: true,
+        linkedTarget: true,
+      },
+    })
+
+    let nextCursor: string | null = null
+    if (runs.length > data.limit) {
+      runs.pop()
+      const last = runs[runs.length - 1]
+      nextCursor = JSON.stringify({ startedAt: last.startedAt.toISOString(), id: last.id })
+    }
+
+    return {
+      runs: runs.map((run) => ({
+        id: run.id,
+        kind: run.activity === "tts" ? "speech" : run.activity ?? run.kind,
+        status: run.status,
+        provider: run.provider ?? undefined,
+        model: run.model ?? undefined,
+        artifacts: run.artifacts as never,
+        result: run.result,
+        usage: run.usage as never,
+        startedAt: run.startedAt,
+        threadId: run.threadId,
+        linkedTarget: parseLinkedTarget(run.linkedTarget),
+      })),
+      nextCursor,
+    }
+  })
+
+/**
+ * 再创作 serverFn（P4c 段二）。
+ *
+ * 用原图作为参考图（image edit 模式）调 generateImageForUser，
+ * 或纯文本 prompt 重生成。
+ */
+const CreateVariantSchema = z.object({
+  sourceRunId: z.string().min(1),
+  prompt: z.string().trim().min(1).optional(),
+  threadId: z.string().min(1),
+})
+
+export const createVariantFn = createServerFn({ method: "POST" })
+  .validator(CreateVariantSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest()
+    await requireFeature(request, "mediaGeneration")
+    await requireResource(request, "mediaGenerationsMonthly")
+
+    const session = await requireAuth(request)
+    if (!session?.user?.id) {
+      return { error: "Unauthorized" }
+    }
+    const userId = session.user.id
+
+    const sourceRun = await prisma.generationRun.findFirst({
+      where: { id: data.sourceRunId, userId, thread: { userId } },
+      select: { artifacts: true, result: true, input: true, activity: true, kind: true, status: true, model: true },
+    })
+    if (!sourceRun) throw new Error("Source run not found")
+    const activity = sourceRun.activity ?? sourceRun.kind
+    if (sourceRun.status !== "completed") throw new Error("Source run must be completed")
+    if (activity === "prototype") throw new Error("Prototype runs cannot be regenerated as variants")
+    if (!["image", "video", "speech", "tts"].includes(activity)) {
+      throw new Error("Source run kind does not support variants")
+    }
+    const thread = await prisma.chatThread.findFirst({
+      where: { id: data.threadId, userId }, select: { id: true },
+    })
+    if (!thread) throw new Error("Thread not found")
+    if (!sourceRun.model) throw new Error("Source model is unavailable")
+    const config = await resolveAiConfigForModel(userId, sourceRun.model)
+    if (!config?.apiKey) throw new Error("AI key not configured for source model")
+    const commonConfig = {
+      adapterKind: config.adapterKind ?? config.providerId,
+      apiKey: config.apiKey, model: config.model,
+      ...(config.baseUrl ? { baseURL: config.baseUrl } : {}),
+    }
+    if (activity === "video") {
+      const input = z.object({ prompt: z.string().optional() }).safeParse(sourceRun.input ?? {})
+      const prompt = data.prompt ?? (input.success ? input.data.prompt : undefined)
+      if (!prompt?.trim()) throw new Error("A prompt is required")
+      const result = await generateVideoForUser({ userId, threadId: data.threadId, prompt, ...commonConfig })
+      return { runId: result.runId, jobId: result.jobId, model: result.model, artifacts: result.artifacts ?? [] }
+    }
+    if (activity === "tts") {
+      const input = z.object({ text: z.string().optional() }).safeParse(sourceRun.input ?? {})
+      const text = (input.success ? input.data.text : undefined) ?? data.prompt
+      if (!text?.trim()) throw new Error("A text is required")
+      const result = await generateSpeechForUser({ userId, threadId: data.threadId, text, ...commonConfig })
+      return { runId: result.runId, id: result.id, model: result.model, audio: result.audio, format: result.format, artifacts: result.artifacts ?? [] }
+    }
+    const input = z.object({ prompt: z.string().optional() }).safeParse(sourceRun.input)
+    const prompt = data.prompt ?? (input.success ? input.data.prompt : undefined)
+    if (!prompt?.trim()) throw new Error("A prompt is required")
+    const images = z.object({ images: z.array(z.object({ url: z.string().optional(), b64Json: z.string().optional() })) }).safeParse(sourceRun.result)
+    const refs = z.array(z.object({ url: z.string().optional(), role: z.string().optional(), mimeType: z.string().optional() })).safeParse(sourceRun.artifacts)
+    const image = images.success ? images.data.images[0] : undefined
+    const referenceImage = (image?.b64Json ? `data:image/png;base64,${image.b64Json}` : image?.url)
+      ?? (refs.success ? refs.data.find(ref => ref.role !== "input" && ref.mimeType?.startsWith("image/"))?.url : undefined)
+    if (!referenceImage) throw new Error("Source image is unavailable")
+    const result = await generateImageForUser({
+      userId, threadId: data.threadId, sourceRunId: data.sourceRunId,
+      prompt, referenceImage, ...commonConfig,
+    })
+    return { runId: result.runId, artifacts: result.artifacts, images: result.images }
+
+  })