@allbluecn/web-app 0.9.4 → 0.10.0

package/src/server/serverFns/project.ts

@@ -22,9 +22,11 @@ import { prisma, Prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
 import { auditLog } from "@/server/audit";
 import { validateDisplayId } from "@/lib/project-display-id";
-import { ensureBuiltinIndependentProject } from "@/server/builtin-project";
+import { ensureBuiltinIndependentProject, migrateStoriesToIndependentProject } from "@/server/builtin-project";
 import { BUILTIN_INDEPENDENT_DISPLAY_ID, BUILTIN_INDEPENDENT_NAME, BUILTIN_INDEPENDENT_ICON } from "@/lib/builtin-project";
 import type { ProjectRole } from "@/types/project";
+import { startOfDay, startOfMonth, endOfMonth, subMonths, eachDayOfInterval } from "date-fns";
+import { formatInTimeZone, toZonedTime, fromZonedTime } from "date-fns-tz";
 
 // 用户精简信息 select
 const USER_BRIEF_SELECT = {
@@ -314,46 +316,13 @@ export const deleteProjectFn = createServerFn({ method: "POST" })
       if (mode === "clear") {
         await prisma.story.deleteMany({ where: { projectId: data.projectId } });
       } else {
-        const independentId = await ensureBuiltinIndependentProject(userId);
         const storyIds = (
           await prisma.story.findMany({
             where: { projectId: data.projectId },
             select: { id: true },
           })
         ).map((s) => s.id);
-
-        const MAX_RETRIES = 5;
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-          try {
-            await prisma.$transaction(async (tx) => {
-              for (const id of storyIds) {
-                const counter = await tx.sequenceCounter.upsert({
-                  where: { scope: independentId },
-                  create: { scope: independentId, seq: 1 },
-                  update: { seq: { increment: 1 } },
-                });
-                await tx.story.update({
-                  where: { id },
-                  data: {
-                    projectId: independentId,
-                    sequenceId: counter.seq,
-                    identifier: `STORY-${counter.seq}`,
-                  },
-                });
-              }
-            });
-            break;
-          } catch (e: unknown) {
-            const isUniqueViolation =
-              e instanceof Error &&
-              "code" in e &&
-              (e as { code: string }).code === "P2002" &&
-              "meta" in e &&
-              Array.isArray((e as { meta?: { target?: string[] } }).meta?.target) &&
-              (e as { meta: { target: string[] } }).meta.target.includes("identifier");
-            if (!isUniqueViolation || attempt === MAX_RETRIES - 1) throw e;
-          }
-        }
+        await migrateStoriesToIndependentProject(userId, storyIds);
       }
     }
     await prisma.project.delete({ where: { id: data.projectId } });
@@ -565,6 +534,50 @@ export const listProjectActivitiesFn = createServerFn({ method: "GET" })
     });
   });
 
+// 获取项目贡献图聚合数据（最近 12 个月，含当前月）
+const projectActivityDataSchema = z.object({
+  projectId: z.string(),
+  timezone: z.string().optional(),
+});
+
+export const getProjectActivityDataFn = createServerFn({ method: "GET" })
+  .validator(projectActivityDataSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    await requireProjectMember(data.projectId, userId);
+
+    const timezone = data.timezone || "Asia/Shanghai";
+    const now = new Date();
+    const monthEnd = endOfMonth(now);
+    const rangeStart = startOfMonth(subMonths(now, 11));
+
+    const dateRange = eachDayOfInterval({ start: rangeStart, end: monthEnd });
+    const dateMap = new Map<string, number>();
+    for (const d of dateRange) {
+      const key = formatInTimeZone(d, timezone, "yyyy-MM-dd");
+      dateMap.set(key, 0);
+    }
+
+    const activities = await prisma.projectActivity.findMany({
+      where: { projectId: data.projectId, createdAt: { gte: rangeStart, lte: monthEnd } },
+      select: { createdAt: true },
+    });
+
+    for (const a of activities) {
+      const key = formatInTimeZone(a.createdAt, timezone, "yyyy-MM-dd");
+      dateMap.set(key, (dateMap.get(key) ?? 0) + 1);
+    }
+
+    const max = Math.max(1, ...dateMap.values());
+    return Array.from(dateMap.entries()).map(([date, count]) => ({
+      date,
+      count,
+      level: count === 0 ? 0 : Math.min(4, Math.max(1, Math.ceil((count / max) * 4))),
+    }));
+  });
+
 // 确保用户拥有内置独立需求项目（供客户端调用）
 export const ensureBuiltinProjectFn = createServerFn({ method: "GET" }).handler(async () => {
   const request = getRequest();

package/src/server/serverFns/story/story-crud/bulk.ts

@@ -73,9 +73,9 @@ const bulkUpdateSchema = z.object({
   storyIds: z.array(z.string()).min(1).max(500),
   patch: z
     .object({
-      state: z.enum(STORY_STATES.map((s) => s.value) as [StoryState, ...StoryState[]]).optional(),
+      state: z.enum(STORY_STATES.map((s: { value: StoryState }) => s.value) as [StoryState, ...StoryState[]]).optional(),
       priority: z
-        .enum(STORY_PRIORITIES.map((p) => p.value) as [StoryPriority, ...StoryPriority[]])
+        .enum(STORY_PRIORITIES.map((p: { value: StoryPriority }) => p.value) as [StoryPriority, ...StoryPriority[]])
         .optional(),
       assigneeId: z.string().nullable().optional(),
       startDate: z.string().nullable().optional(),

package/src/server/serverFns/story/story-crud.ts

@@ -110,7 +110,8 @@ export const createStoryFn = createServerFn({ method: "POST" })
       projectId = await ensureBuiltinIndependentProject(userId);
     }
 
-    await validateAssignee(projectId, data.assigneeId);
+    const resolvedProjectId = projectId!;
+    await validateAssignee(resolvedProjectId, data.assigneeId);
 
     const MAX_RETRIES = 5;
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
@@ -131,10 +132,11 @@ export const createStoryFn = createServerFn({ method: "POST" })
           if (!project) throw new Error("项目不存在");
 
           const isIndependent = project.displayId === BUILTIN_INDEPENDENT_DISPLAY_ID;
+          const pid = projectId!;
           if (isIndependent) {
             const counter = await tx.sequenceCounter.upsert({
-              where: { scope: projectId },
-              create: { scope: projectId, seq: 1 },
+              where: { scope: pid },
+              create: { scope: pid, seq: 1 },
               update: { seq: { increment: 1 } },
             });
             sequenceId = counter.seq;
@@ -145,8 +147,8 @@ export const createStoryFn = createServerFn({ method: "POST" })
                 .replace(/[^a-zA-Z0-9]/g, "")
                 .toUpperCase() || "PRJ";
             const counter = await tx.sequenceCounter.upsert({
-              where: { scope: projectId },
-              create: { scope: projectId, seq: 1 },
+              where: { scope: pid },
+              create: { scope: pid, seq: 1 },
               update: { seq: { increment: 1 } },
             });
             sequenceId = counter.seq;
@@ -159,7 +161,7 @@ export const createStoryFn = createServerFn({ method: "POST" })
               identifier,
               name: data.name,
               description: data.description ?? null,
-              projectId,
+              projectId: projectId!,
               parentId: data.parentId || null,
               state: data.state,
               priority: data.priority,
@@ -194,7 +196,7 @@ export const createStoryFn = createServerFn({ method: "POST" })
             parentActivity = toActivityItem(pa);
           }
 
-          return { ...castStoryUsers(story), activities: parentActivity ? [parentActivity] : [] };
+          return { ...castStoryUsers(story), activities: parentActivity ? [parentActivity] : [] } satisfies Awaited<ReturnType<typeof prisma.$transaction>>;
         });
       } catch (e: unknown) {
         const isUniqueViolation =

package/src/server/serverFns/story/story-groups.ts

@@ -22,7 +22,7 @@ import { prisma, Prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
 import { ensureBuiltinIndependentProject } from "@/server/builtin-project";
 import { GROUP_KEYS, ORDER_KEYS, ORDER_DIRECTIONS, type GroupKey, type OrderKey } from "@/components/story/display/types";
-import { STORY_STATES, STORY_PRIORITIES } from "@/components/story/constants";
+import { STORY_STATES, STORY_PRIORITIES, type StoryState, type StoryPriority } from "@/components/story/constants";
 import { STORY_LIST_SELECT_LIGHT, castStoryUsersLight, type StoryListRowLight } from "./types";
 import { buildListWhere, buildGroupFilter } from "./story-list-query";
 
@@ -222,8 +222,8 @@ function deriveGroupKey(groupBy: GroupKey, row: Record<string, unknown>): string
 
 /** 组间显示顺序与筛选 pop 的值顺序一致（state/priority 按枚举序，其余维度保持 DB 返回序；未知 key 排最后） */
 const GROUP_DISPLAY_ORDER: Partial<Record<GroupKey, readonly string[]>> = {
-  state: STORY_STATES.map((s) => s.value),
-  priority: STORY_PRIORITIES.map((p) => p.value),
+  state: STORY_STATES.map((s: { value: StoryState }) => s.value),
+  priority: STORY_PRIORITIES.map((p: { value: StoryPriority }) => p.value),
 };
 
 function sortGroupKeys(groupBy: GroupKey, keys: string[]): string[] {
@@ -260,9 +260,9 @@ export const listStoryGroupsFn = createServerFn({ method: "GET" })
 
     if (data.showEmptyGroups) {
       if (data.groupBy === "state") {
-        keys.push(...STORY_STATES.map((s) => s.value));
+        keys.push(...STORY_STATES.map((s: { value: StoryState }) => s.value));
       } else if (data.groupBy === "priority") {
-        keys.push(...STORY_PRIORITIES.map((p) => p.value));
+        keys.push(...STORY_PRIORITIES.map((p: { value: StoryPriority }) => p.value));
       }
     }
 
@@ -298,7 +298,7 @@ export const listStoryGroupsFn = createServerFn({ method: "GET" })
     }
 
     const counts = await prisma.story.groupBy({
-      by: [GROUP_BY_FIELD[data.groupBy]],
+      by: [(GROUP_BY_FIELD as Record<string, Prisma.StoryScalarFieldEnum>)[data.groupBy]],
       where,
       _count: { _all: true },
     });

package/src/server/serverFns/workspace.ts

@@ -20,7 +20,10 @@ import { getRequest } from "@tanstack/react-start/server";
 import { z } from "zod";
 import { prisma, Prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
+import { migrateStoriesToIndependentProject } from "@/server/builtin-project";
 import { requireResource } from "@/server/resources";
+import { startOfMonth, endOfMonth, subMonths, eachDayOfInterval } from "date-fns";
+import { formatInTimeZone } from "date-fns-tz";
 
 const USER_BRIEF_SELECT = {
   id: true,
@@ -55,6 +58,7 @@ export const listWorkspacesFn = createServerFn({ method: "GET" }).handler(
         name: true,
         description: true,
         icon: true,
+        pinnedToSidebar: true,
         ownerId: true,
         createdAt: true,
         updatedAt: true,
@@ -79,6 +83,40 @@ export const listWorkspacesBriefFn = createServerFn({ method: "GET" }).handler(
   },
 );
 
+export const listPinnedWorkspacesBriefFn = createServerFn({ method: "GET" }).handler(
+  async () => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+
+    return prisma.workspace.findMany({
+      where: { ownerId: userId, pinnedToSidebar: true },
+      orderBy: { name: "asc" },
+      select: { id: true, name: true, icon: true },
+    });
+  },
+);
+
+const pinToggleSchema = z.object({
+  workspaceId: z.string(),
+  pinned: z.boolean(),
+});
+
+export const toggleWorkspacePinFn = createServerFn({ method: "POST" })
+  .validator(pinToggleSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, userId);
+
+    await prisma.workspace.update({
+      where: { id: data.workspaceId },
+      data: { pinnedToSidebar: data.pinned },
+    });
+    return { success: true, pinned: data.pinned };
+  });
+
 const createSchema = z.object({
   icon: z.string().default("folder"),
   name: z.string().min(1).max(100),
@@ -103,6 +141,17 @@ export const createWorkspaceFn = createServerFn({ method: "POST" })
           ownerId: userId,
         },
       });
+      await tx.knowledgeBase.create({
+        data: {
+          name: data.name,
+          description: `${data.name}工作空间同步创建的知识库`,
+          icon: "notebook",
+          tags: [],
+          visibility: "team",
+          userId,
+          workspaceId: workspace.id,
+        },
+      });
       return workspace;
     });
   });
@@ -189,6 +238,8 @@ const deleteSchema = z.object({
   workspaceId: z.string(),
   mode: z.enum(["clear", "transfer"]).optional(),
   targetWorkspaceId: z.string().optional(),
+  storyMode: z.enum(["transfer", "clear"]).optional(),
+  knowledgeBaseMode: z.enum(["delete", "keep"]).default("delete"),
 });
 
 export const deleteWorkspaceFn = createServerFn({ method: "POST" })
@@ -207,25 +258,295 @@ export const deleteWorkspaceFn = createServerFn({ method: "POST" })
     }
 
     const mode = data.mode ?? "transfer";
-    if (projectCount > 0) {
-      if (mode === "clear") {
-        await prisma.project.deleteMany({
+    if (projectCount > 0 && mode === "transfer") {
+      if (!data.targetWorkspaceId) {
+        throw new Error("转移模式必须指定目标工作空间");
+      }
+      if (data.targetWorkspaceId === data.workspaceId) {
+        throw new Error("不可转移到自身");
+      }
+      await requireWorkspaceOwner(data.targetWorkspaceId, userId);
+    }
+
+    // 清空模式下需求（stories）的处理与删除项目逻辑保持一致：
+    // transfer → 迁移到用户「独立需求」内置项目；clear → 直接删除
+    if (projectCount > 0 && mode === "clear" && (data.storyMode ?? "transfer") === "transfer") {
+      const storyIds = (
+        await prisma.story.findMany({
+          where: { project: { workspaceId: data.workspaceId } },
+          select: { id: true },
+        })
+      ).map((s) => s.id);
+      await migrateStoriesToIndependentProject(userId, storyIds);
+    }
+
+    await prisma.$transaction(async (tx) => {
+      if (projectCount > 0) {
+        if (mode === "clear") {
+          // Story 对 project 为 Restrict 外键，storyMode=transfer 时需求已迁走，此处兜底清空残留
+          if ((data.storyMode ?? "transfer") === "clear") {
+            await tx.story.deleteMany({
+              where: { project: { workspaceId: data.workspaceId } },
+            });
+          }
+          await tx.project.deleteMany({
+            where: { workspaceId: data.workspaceId },
+          });
+        } else {
+          await tx.project.updateMany({
+            where: { workspaceId: data.workspaceId },
+            data: { workspaceId: data.targetWorkspaceId },
+          });
+        }
+      }
+
+      // 处理关联知识库
+      if (data.knowledgeBaseMode === "delete") {
+        await tx.knowledgeBase.deleteMany({
           where: { workspaceId: data.workspaceId },
         });
       } else {
-        if (!data.targetWorkspaceId) {
-          throw new Error("转移模式必须指定目标工作空间");
-        }
-        if (data.targetWorkspaceId === data.workspaceId) {
-          throw new Error("不可转移到自身");
-        }
-        await requireWorkspaceOwner(data.targetWorkspaceId, userId);
-        await prisma.project.updateMany({
+        await tx.knowledgeBase.updateMany({
           where: { workspaceId: data.workspaceId },
-          data: { workspaceId: data.targetWorkspaceId },
+          data: { workspaceId: null },
         });
       }
+
+      // 清理无 onDelete 级联的关联记录，避免外键约束阻止删除
+      await tx.usageRecord.deleteMany({
+        where: { workspaceId: data.workspaceId },
+      });
+      await tx.aiUsageLog.deleteMany({
+        where: { workspaceId: data.workspaceId },
+      });
+      await tx.ssoProvider.deleteMany({
+        where: { workspaceId: data.workspaceId },
+      });
+      await tx.customRole.deleteMany({
+        where: { workspaceId: data.workspaceId },
+      });
+      // 审计日志保留，仅断开关联
+      await tx.auditLog.updateMany({
+        where: { workspaceId: data.workspaceId },
+        data: { workspaceId: null },
+      });
+
+      await tx.workspace.delete({ where: { id: data.workspaceId } });
+    });
+    return { success: true };
+  });
+
+// 工作空间活动记录（最近 N 条）
+const workspaceActivitiesSchema = z.object({
+  workspaceId: z.string(),
+  take: z.number().int().min(1).max(50).default(15),
+});
+
+export const listWorkspaceActivitiesFn = createServerFn({ method: "GET" })
+  .validator(workspaceActivitiesSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, userId);
+
+    const projects = await prisma.project.findMany({
+      where: { workspaceId: data.workspaceId },
+      select: { id: true, name: true },
+    });
+    const projectIds = projects.map((p) => p.id);
+
+    if (projectIds.length === 0) return [];
+
+    return prisma.projectActivity.findMany({
+      where: { projectId: { in: projectIds } },
+      orderBy: { createdAt: "desc" },
+      take: data.take,
+      select: {
+        id: true,
+        projectId: true,
+        userId: true,
+        action: true,
+        targetType: true,
+        targetId: true,
+        metadata: true,
+        createdAt: true,
+        user: { select: USER_BRIEF_SELECT },
+        project: { select: { id: true, name: true } },
+      },
+    });
+  });
+
+// 工作空间贡献度数据（最近 12 个月聚合）
+const workspaceActivityDataSchema = z.object({
+  workspaceId: z.string(),
+  timezone: z.string().optional(),
+});
+
+export const getWorkspaceActivityDataFn = createServerFn({ method: "GET" })
+  .validator(workspaceActivityDataSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, userId);
+
+    const projects = await prisma.project.findMany({
+      where: { workspaceId: data.workspaceId },
+      select: { id: true },
+    });
+    const projectIds = projects.map((p) => p.id);
+    if (projectIds.length === 0) return [];
+
+    const timezone = data.timezone || "Asia/Shanghai";
+    const now = new Date();
+    const monthEnd = endOfMonth(now);
+    const rangeStart = startOfMonth(subMonths(now, 11));
+
+    const dateRange = eachDayOfInterval({ start: rangeStart, end: monthEnd });
+    const dateMap = new Map<string, number>();
+    for (const d of dateRange) {
+      const key = formatInTimeZone(d, timezone, "yyyy-MM-dd");
+      dateMap.set(key, 0);
+    }
+
+    const activities = await prisma.projectActivity.findMany({
+      where: {
+        projectId: { in: projectIds },
+        createdAt: { gte: rangeStart, lte: monthEnd },
+      },
+      select: { createdAt: true },
+    });
+
+    for (const a of activities) {
+      const key = formatInTimeZone(a.createdAt, timezone, "yyyy-MM-dd");
+      dateMap.set(key, (dateMap.get(key) ?? 0) + 1);
     }
-    await prisma.workspace.delete({ where: { id: data.workspaceId } });
+
+    const max = Math.max(1, ...dateMap.values());
+    return Array.from(dateMap.entries()).map(([date, count]) => ({
+      date,
+      count,
+      level: count === 0 ? 0 : Math.min(4, Math.max(1, Math.ceil((count / max) * 4))),
+    }));
+  });
+
+// ---------- 工作空间成员 ----------
+
+const workspaceMemberSchema = z.object({
+  workspaceId: z.string(),
+});
+
+export const listWorkspaceMembersFn = createServerFn({ method: "GET" })
+  .validator(workspaceMemberSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, userId);
+
+    const [members, owner] = await Promise.all([
+      prisma.workspaceMember.findMany({
+        where: { workspaceId: data.workspaceId, status: "active" },
+        orderBy: [{ role: "asc" }, { joinedAt: "asc" }],
+        select: {
+          id: true,
+          userId: true,
+          role: true,
+          status: true,
+          joinedAt: true,
+          user: { select: USER_BRIEF_SELECT },
+        },
+      }),
+      prisma.workspace.findUnique({
+        where: { id: data.workspaceId },
+        select: { ownerId: true, owner: { select: USER_BRIEF_SELECT } },
+      }),
+    ]);
+
+    const ownerMember = owner
+      ? {
+          id: `owner-${owner.ownerId}`,
+          userId: owner.ownerId,
+          role: "owner",
+          status: "active",
+          joinedAt: new Date(),
+          user: owner.owner,
+        }
+      : null;
+
+    return [ownerMember, ...members.filter((m) => m.userId !== owner?.ownerId)].filter(Boolean);
+  });
+
+const addWorkspaceMemberSchema = z.object({
+  workspaceId: z.string(),
+  userId: z.string(),
+  role: z.enum(["admin", "member", "viewer"]).default("member"),
+});
+
+export const addWorkspaceMemberFn = createServerFn({ method: "POST" })
+  .validator(addWorkspaceMemberSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const currentUserId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, currentUserId);
+
+    const workspace = await prisma.workspace.findUnique({
+      where: { id: data.workspaceId },
+      select: { ownerId: true },
+    });
+    if (!workspace) throw new Error("工作空间不存在");
+
+    if (data.userId === workspace.ownerId) throw new Error("所有者已是成员");
+
+    const membership = await prisma.teamMembership.findUnique({
+      where: { memberId: data.userId },
+      select: { ownerId: true, seatType: true },
+    });
+    if (!membership || membership.ownerId !== workspace.ownerId) {
+      throw new Error("仅可添加团队成员");
+    }
+
+    const existing = await prisma.workspaceMember.findUnique({
+      where: { workspaceId_userId: { workspaceId: data.workspaceId, userId: data.userId } },
+      select: { id: true },
+    });
+    if (existing) throw new Error("该用户已是工作空间成员");
+
+    await prisma.workspaceMember.create({
+      data: {
+        workspaceId: data.workspaceId,
+        userId: data.userId,
+        role: data.role,
+        status: "active",
+      },
+    });
+    return { success: true };
+  });
+
+const removeWorkspaceMemberSchema = z.object({
+  workspaceId: z.string(),
+  userId: z.string(),
+});
+
+export const removeWorkspaceMemberFn = createServerFn({ method: "POST" })
+  .validator(removeWorkspaceMemberSchema)
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const currentUserId = session.user!.id!;
+    await requireWorkspaceOwner(data.workspaceId, currentUserId);
+
+    if (data.userId === (await prisma.workspace.findUnique({
+      where: { id: data.workspaceId },
+      select: { ownerId: true },
+    }))?.ownerId) {
+      throw new Error("不可移除工作空间所有者");
+    }
+
+    await prisma.workspaceMember.deleteMany({
+      where: { workspaceId: data.workspaceId, userId: data.userId },
+    });
     return { success: true };
   });

package/src/server-entry.ts

@@ -0,0 +1,29 @@
+import { createStartHandler, defaultStreamHandler } from '@tanstack/react-start/server'
+import { isUnauthorizedError } from '@/lib/auth/anonymous-safe'
+import { paraglideMiddleware } from '@/paraglide/server.js'
+
+const handler = async ({ request, router, responseHeaders }: any) => {
+  const result: any = await defaultStreamHandler({ request, router, responseHeaders })
+  if (router._serverResult?.type === 'render' && router._serverResult.status === 500) {
+    const matches = router.stores.matches.get()
+    for (const match of matches) {
+      if (match.status === 'error' && isUnauthorizedError(match.error)) {
+        const response = result.response ?? result
+        return {
+          ...result,
+          response: new Response(response.body, {
+            status: 401,
+            headers: response.headers,
+          }),
+        }
+      }
+    }
+  }
+  return result
+}
+
+const fetch = createStartHandler(handler)
+
+export default {
+  fetch: (req: Request): Promise<Response> => paraglideMiddleware(req, () => fetch(req)),
+}

package/vite.shared.ts

@@ -110,7 +110,10 @@ export function createWebViteConfig(opts: WebViteConfigOptions) {
     const deployTarget = process.env.DEPLOY_TARGET
     const plugins: PluginOption[] = [...opts.basePlugins, tiptapAliasPlugin(opts.rootDir)]
 
-    if (deployTarget === 'vercel') {
+    // Vercel 平台自动注入 VERCEL_ENV 环境变量，nitro 插件始终挂载。DEPLOY_TARGET=vercel
+    // 保留作为本地兼容触发器（Pro 仓 build.sh 及本地 vercel preview 均依赖它）。
+    const isVercelTarget = deployTarget === 'vercel' || !!process.env.VERCEL_ENV
+    if (isVercelTarget) {
       const { nitro } = await import('nitro/vite')
       plugins.splice(2, 0, nitro({ preset: 'vercel' }))
       plugins.push(prismaDirnamePolyfill(opts.rootDir))