@lobehub/chat 0.162.25 → 0.163.0

package/src/features/User/UserPanel/useMenu.tsx

@@ -1,5 +1,6 @@
 import { ActionIcon, DiscordIcon, Icon } from '@lobehub/ui';
 import { Badge } from 'antd';
+import { ItemType } from 'antd/es/menu/interface';
 import {
   Book,
   CircleUserRound,
@@ -21,6 +22,7 @@ import urlJoin from 'url-join';
 
 import type { MenuProps } from '@/components/Menu';
 import { DISCORD, DOCUMENTS, EMAIL_SUPPORT, GITHUB_ISSUES, mailTo } from '@/const/url';
+import { isServerMode } from '@/const/version';
 import DataImporter from '@/features/DataImporter';
 import { useOpenSettings } from '@/hooks/useInterceptingRoutes';
 import { usePWAInstall } from '@/hooks/usePWAInstall';
@@ -115,46 +117,50 @@ export const useMenu = () => {
     },
   ];
 
-  const data: MenuProps['items'] = [
-    {
-      icon: <Icon icon={HardDriveUpload} />,
-      key: 'import',
-      label: <DataImporter>{t('import')}</DataImporter>,
-    },
-    {
-      children: [
+  const data = !isLogin
+    ? []
+    : ([
         {
-          key: 'allAgent',
-          label: t('exportType.allAgent'),
-          onClick: configService.exportAgents,
-        },
-        {
-          key: 'allAgentWithMessage',
-          label: t('exportType.allAgentWithMessage'),
-          onClick: configService.exportSessions,
-        },
-        {
-          key: 'globalSetting',
-          label: t('exportType.globalSetting'),
-          onClick: configService.exportSettings,
+          icon: <Icon icon={HardDriveDownload} />,
+          key: 'import',
+          label: <DataImporter>{t('import')}</DataImporter>,
         },
+        isServerMode
+          ? null
+          : {
+              children: [
+                {
+                  key: 'allAgent',
+                  label: t('exportType.allAgent'),
+                  onClick: configService.exportAgents,
+                },
+                {
+                  key: 'allAgentWithMessage',
+                  label: t('exportType.allAgentWithMessage'),
+                  onClick: configService.exportSessions,
+                },
+                {
+                  key: 'globalSetting',
+                  label: t('exportType.globalSetting'),
+                  onClick: configService.exportSettings,
+                },
+                {
+                  type: 'divider',
+                },
+                {
+                  key: 'all',
+                  label: t('exportType.all'),
+                  onClick: configService.exportAll,
+                },
+              ],
+              icon: <Icon icon={HardDriveUpload} />,
+              key: 'export',
+              label: t('export'),
+            },
         {
           type: 'divider',
         },
-        {
-          key: 'all',
-          label: t('exportType.all'),
-          onClick: configService.exportAll,
-        },
-      ],
-      icon: <Icon icon={HardDriveDownload} />,
-      key: 'export',
-      label: t('export'),
-    },
-    {
-      type: 'divider',
-    },
-  ];
+      ].filter(Boolean) as ItemType[]);
 
   const helps: MenuProps['items'] = [
     {
@@ -209,13 +215,13 @@ export const useMenu = () => {
     {
       type: 'divider',
     },
-    ...(isLoginWithClerk ? profile : []),
     ...(isLogin ? settings : []),
+    ...(isLoginWithClerk ? profile : []),
     /* ↓ cloud slot ↓ */
 
     /* ↑ cloud slot ↑ */
     ...(canInstall ? pwa : []),
-    ...(isLogin ? data : []),
+    ...data,
     ...helps,
   ].filter(Boolean) as MenuProps['items'];
 

package/src/libs/trpc/client.ts

@@ -1,16 +1,65 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import superjson from 'superjson';
 
-import type { EdgeRouter } from '@/server/routers';
-import { createHeaderWithAuth } from '@/services/_auth';
+import { fetchErrorNotification } from '@/components/FetchErrorNotification';
+import type { EdgeRouter } from '@/server/routers/edge';
+import type { LambdaRouter } from '@/server/routers/lambda';
 import { withBasePath } from '@/utils/basePath';
 
 export const edgeClient = createTRPCClient<EdgeRouter>({
   links: [
     httpBatchLink({
-      headers: async () => createHeaderWithAuth(),
+      headers: async () => {
+        // dynamic import to avoid circular dependency
+        const { createHeaderWithAuth } = await import('@/services/_auth');
+
+        return createHeaderWithAuth();
+      },
       transformer: superjson,
       url: withBasePath('/trpc/edge'),
     }),
   ],
 });
+
+export type ErrorResponse = ErrorItem[];
+
+export interface ErrorItem {
+  error: {
+    json: {
+      code: number;
+      data: Data;
+      message: string;
+    };
+  };
+}
+
+export interface Data {
+  code: string;
+  httpStatus: number;
+  path: string;
+  stack: string;
+}
+
+export const lambdaClient = createTRPCClient<LambdaRouter>({
+  links: [
+    httpBatchLink({
+      fetch: async (input, init) => {
+        const response = await fetch(input, init);
+        if (response.ok) return response;
+
+        const errorRes: ErrorResponse = await response.clone().json();
+
+        errorRes.forEach((item) => {
+          const errorData = item.error.json;
+
+          const status = errorData.data.httpStatus;
+          fetchErrorNotification.error({ errorMessage: errorData.message, status });
+        });
+
+        return response;
+      },
+      transformer: superjson,
+      url: '/trpc/lambda',
+    }),
+  ],
+});

package/src/server/files/s3.ts

@@ -1,4 +1,9 @@
-import { ListObjectsCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import {
+  GetObjectCommand,
+  ListObjectsCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { z } from 'zod';
 
@@ -46,6 +51,21 @@ export class S3 {
     return listFileSchema.parse(res.Contents);
   }
 
+  public async getFileContent(key: string): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+    });
+
+    const response = await this.client.send(command);
+
+    if (!response.Body) {
+      throw new Error(`No body in response with ${key}`);
+    }
+
+    return response.Body.transformToString();
+  }
+
   public async createPreSignedUrl(key: string): Promise<string> {
     const command = new PutObjectCommand({
       ACL: 'public-read',

package/src/server/keyVaultsEncrypt/index.test.ts

@@ -0,0 +1,62 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { KeyVaultsGateKeeper } from './index';
+
+describe('KeyVaultsGateKeeper', () => {
+  let gateKeeper: KeyVaultsGateKeeper;
+
+  beforeEach(async () => {
+    process.env.KEY_VAULTS_SECRET = 'Q10pwdq00KXUu9R+c8A8p4PSlIRWi7KwgUophBtkHVk=';
+    // 在每个测试用例运行前初始化 KeyVaultsGateKeeper 实例
+    gateKeeper = await KeyVaultsGateKeeper.initWithEnvKey();
+  });
+
+  it('should encrypt and decrypt data correctly', async () => {
+    const originalData = 'sensitive user data';
+
+    // 加密数据
+    const encryptedData = await gateKeeper.encrypt(originalData);
+
+    // 解密数据
+    const decryptionResult = await gateKeeper.decrypt(encryptedData);
+
+    // 断言解密后的明文与原始数据相同
+    expect(decryptionResult.plaintext).toBe(originalData);
+    // 断言解密是真实的(通过认证)
+    expect(decryptionResult.wasAuthentic).toBe(true);
+  });
+
+  it('should return empty plaintext and false authenticity for invalid encrypted data', async () => {
+    const invalidEncryptedData = 'invalid:encrypted:data';
+
+    // 尝试解密无效的加密数据
+    const decryptionResult = await gateKeeper.decrypt(invalidEncryptedData);
+
+    // 断言解密后的明文为空字符串
+    expect(decryptionResult.plaintext).toBe('');
+    // 断言解密是不真实的(未通过认证)
+    expect(decryptionResult.wasAuthentic).toBe(false);
+  });
+
+  it('should throw an error if KEY_VAULTS_SECRET is not set', async () => {
+    // 将 KEY_VAULTS_SECRET 设为 undefined
+    const originalSecretKey = process.env.KEY_VAULTS_SECRET;
+    process.env.KEY_VAULTS_SECRET = '';
+
+    // 断言在 KEY_VAULTS_SECRET 未设置时会抛出错误
+    try {
+      await KeyVaultsGateKeeper.initWithEnvKey();
+    } catch (e) {
+      expect(e).toEqual(
+        Error(` \`KEY_VAULTS_SECRET\` is not set, please set it in your environment variables.
+
+If you don't have it, please run \`openssl rand -base64 32\` to create one.
+`),
+      );
+    }
+
+    // 恢复 KEY_VAULTS_SECRET 的原始值
+    process.env.KEY_VAULTS_SECRET = originalSecretKey;
+  });
+});

package/src/server/keyVaultsEncrypt/index.ts

@@ -0,0 +1,93 @@
+import { getServerDBConfig } from '@/config/db';
+
+interface DecryptionResult {
+  plaintext: string;
+  wasAuthentic: boolean;
+}
+
+export class KeyVaultsGateKeeper {
+  private aesKey: CryptoKey;
+
+  constructor(aesKey: CryptoKey) {
+    this.aesKey = aesKey;
+  }
+
+  static initWithEnvKey = async () => {
+    const { KEY_VAULTS_SECRET } = getServerDBConfig();
+    if (!KEY_VAULTS_SECRET)
+      throw new Error(` \`KEY_VAULTS_SECRET\` is not set, please set it in your environment variables.
+
+If you don't have it, please run \`openssl rand -base64 32\` to create one.
+`);
+
+    const rawKey = Buffer.from(KEY_VAULTS_SECRET, 'base64'); // 确保密钥是32字节（256位）
+    const aesKey = await crypto.subtle.importKey(
+      'raw',
+      rawKey,
+      { length: 256, name: 'AES-GCM' },
+      false,
+      ['encrypt', 'decrypt'],
+    );
+    return new KeyVaultsGateKeeper(aesKey);
+  };
+
+  /**
+   * encrypt user private data
+   */
+  encrypt = async (keyVault: string): Promise<string> => {
+    const iv = crypto.getRandomValues(new Uint8Array(12)); // 对于GCM，推荐使用12字节的IV
+    const encodedKeyVault = new TextEncoder().encode(keyVault);
+
+    const encryptedData = await crypto.subtle.encrypt(
+      {
+        iv: iv,
+        name: 'AES-GCM',
+      },
+      this.aesKey,
+      encodedKeyVault,
+    );
+
+    const buffer = Buffer.from(encryptedData);
+    const authTag = buffer.slice(-16); // 认证标签在加密数据的最后16字节
+    const encrypted = buffer.slice(0, -16); // 剩下的是加密数据
+
+    return `${Buffer.from(iv).toString('hex')}:${authTag.toString('hex')}:${encrypted.toString('hex')}`;
+  };
+
+  // 假设密钥和加密数据是从外部获取的
+  decrypt = async (encryptedData: string): Promise<DecryptionResult> => {
+    const parts = encryptedData.split(':');
+    if (parts.length !== 3) {
+      throw new Error('Invalid encrypted data format');
+    }
+
+    const iv = Buffer.from(parts[0], 'hex');
+    const authTag = Buffer.from(parts[1], 'hex');
+    const encrypted = Buffer.from(parts[2], 'hex');
+
+    // 合并加密数据和认证标签
+    const combined = Buffer.concat([encrypted, authTag]);
+
+    try {
+      const decryptedBuffer = await crypto.subtle.decrypt(
+        {
+          iv: iv,
+          name: 'AES-GCM',
+        },
+        this.aesKey,
+        combined,
+      );
+
+      const decrypted = new TextDecoder().decode(decryptedBuffer);
+      return {
+        plaintext: decrypted,
+        wasAuthentic: true,
+      };
+    } catch {
+      return {
+        plaintext: '',
+        wasAuthentic: false,
+      };
+    }
+  };
+}

package/src/server/mock.ts

@@ -3,6 +3,6 @@
  */
 import { createCallerFactory } from '@/libs/trpc';
 
-import { edgeRouter } from './routers';
+import { edgeRouter } from './routers/edge';
 
 export const createCaller = createCallerFactory(edgeRouter);

package/src/server/routers/{index.ts → edge/index.ts}

@@ -1,10 +1,10 @@
 /**
- * This file contains the root router of lobe chat tRPC-backend
+ * This file contains the root router of Lobe Chat tRPC-backend
  */
 import { publicProcedure, router } from '@/libs/trpc';
 
-import { configRouter } from './edge/config';
-import { uploadRouter } from './edge/upload';
+import { configRouter } from './config';
+import { uploadRouter } from './upload';
 
 export const edgeRouter = router({
   config: configRouter,

package/src/server/routers/lambda/file.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+import { FileModel } from '@/database/server/models/file';
+import { authedProcedure, router } from '@/libs/trpc';
+import { UploadFileSchema } from '@/types/files';
+
+const fileProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: { fileModel: new FileModel(ctx.userId) },
+  });
+});
+
+export const fileRouter = router({
+  createFile: fileProcedure
+    .input(
+      UploadFileSchema.omit({ data: true, saveMode: true, url: true }).extend({ url: z.string() }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      return ctx.fileModel.create({
+        fileType: input.fileType,
+        metadata: input.metadata,
+        name: input.name,
+        size: input.size,
+        url: input.url,
+      });
+    }),
+
+  findById: fileProcedure
+    .input(
+      z.object({
+        id: z.string(),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      return ctx.fileModel.findById(input.id);
+    }),
+
+  removeAllFiles: fileProcedure.mutation(async ({ ctx }) => {
+    return ctx.fileModel.clear();
+  }),
+
+  removeFile: fileProcedure.input(z.object({ id: z.string() })).mutation(async ({ input, ctx }) => {
+    return ctx.fileModel.delete(input.id);
+  }),
+});
+
+export type FileRouter = typeof fileRouter;

package/src/server/routers/lambda/importer.ts

@@ -0,0 +1,54 @@
+// import urlJoin from 'url-join';
+import { TRPCError } from '@trpc/server';
+import { z } from 'zod';
+
+// import { fileEnv } from '@/config/file';
+import { DataImporter } from '@/database/server/modules/DataImporter';
+import { authedProcedure, router } from '@/libs/trpc';
+import { S3 } from '@/server/files/s3';
+import { ImportResults, ImporterEntryData } from '@/types/importer';
+
+export const importerRouter = router({
+  importByFile: authedProcedure
+    .input(z.object({ pathname: z.string() }))
+    .mutation(async ({ input, ctx }): Promise<ImportResults> => {
+      let data: ImporterEntryData | undefined;
+
+      try {
+        const s3 = new S3();
+        const dataStr = await s3.getFileContent(input.pathname);
+        data = JSON.parse(dataStr);
+      } catch {
+        data = undefined;
+      }
+
+      if (!data) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: `Failed to read file at ${input.pathname}`,
+        });
+      }
+
+      const dataImporter = new DataImporter(ctx.userId);
+
+      return dataImporter.importData(data);
+    }),
+
+  importByPost: authedProcedure
+    .input(
+      z.object({
+        data: z.object({
+          messages: z.array(z.any()).optional(),
+          sessionGroups: z.array(z.any()).optional(),
+          sessions: z.array(z.any()).optional(),
+          topics: z.array(z.any()).optional(),
+          version: z.number(),
+        }),
+      }),
+    )
+    .mutation(async ({ input, ctx }): Promise<ImportResults> => {
+      const dataImporter = new DataImporter(ctx.userId);
+
+      return dataImporter.importData(input.data);
+    }),
+});

package/src/server/routers/lambda/index.ts

@@ -0,0 +1,28 @@
+/**
+ * This file contains the root router of Lobe Chat tRPC-backend
+ */
+import { publicProcedure, router } from '@/libs/trpc';
+
+// router that connect to db
+import { fileRouter } from './file';
+import { importerRouter } from './importer';
+import { messageRouter } from './message';
+import { pluginRouter } from './plugin';
+import { sessionRouter } from './session';
+import { sessionGroupRouter } from './sessionGroup';
+import { topicRouter } from './topic';
+import { userRouter } from './user';
+
+export const lambdaRouter = router({
+  file: fileRouter,
+  healthcheck: publicProcedure.query(() => "i'm live!"),
+  importer: importerRouter,
+  message: messageRouter,
+  plugin: pluginRouter,
+  session: sessionRouter,
+  sessionGroup: sessionGroupRouter,
+  topic: topicRouter,
+  user: userRouter,
+});
+
+export type LambdaRouter = typeof lambdaRouter;

package/src/server/routers/lambda/message.ts

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+
+import { MessageModel } from '@/database/server/models/message';
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc';
+import { ChatMessage } from '@/types/message';
+import { BatchTaskResult } from '@/types/service';
+
+type ChatMessageList = ChatMessage[];
+
+const messageProcedure = authedProcedure.use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: { messageModel: new MessageModel(ctx.userId) },
+  });
+});
+
+export const messageRouter = router({
+  batchCreateMessages: messageProcedure
+    .input(z.array(z.any()))
+    .mutation(async ({ input, ctx }): Promise<BatchTaskResult> => {
+      const data = await ctx.messageModel.batchCreate(input);
+
+      return { added: data.rowCount as number, ids: [], skips: [], success: true };
+    }),
+
+  count: messageProcedure.query(async ({ ctx }) => {
+    return ctx.messageModel.count();
+  }),
+  countToday: messageProcedure.query(async ({ ctx }) => {
+    return ctx.messageModel.countToday();
+  }),
+
+  createMessage: messageProcedure
+    .input(z.object({}).passthrough().partial())
+    .mutation(async ({ input, ctx }) => {
+      const data = await ctx.messageModel.create(input as any);
+
+      return data.id;
+    }),
+
+  getAllMessages: messageProcedure.query(async ({ ctx }): Promise<ChatMessageList> => {
+    return ctx.messageModel.queryAll();
+  }),
+
+  getAllMessagesInSession: messageProcedure
+    .input(
+      z.object({
+        sessionId: z.string().nullable().optional(),
+      }),
+    )
+    .query(async ({ ctx, input }): Promise<ChatMessageList> => {
+      return ctx.messageModel.queryBySessionId(input.sessionId);
+    }),
+
+  getMessages: publicProcedure
+    .input(
+      z.object({
+        current: z.number().optional(),
+        pageSize: z.number().optional(),
+        sessionId: z.string().nullable().optional(),
+        topicId: z.string().nullable().optional(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      if (!ctx.userId) return [];
+
+      const messageModel = new MessageModel(ctx.userId);
+
+      return messageModel.query(input);
+    }),
+
+  removeAllMessages: messageProcedure.mutation(async ({ ctx }) => {
+    return ctx.messageModel.deleteAllMessages();
+  }),
+
+  removeMessage: messageProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      return ctx.messageModel.deleteMessage(input.id);
+    }),
+
+  removeMessages: messageProcedure
+    .input(
+      z.object({
+        sessionId: z.string().nullable().optional(),
+        topicId: z.string().nullable().optional(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.messageModel.deleteMessages(input.sessionId, input.topicId);
+    }),
+
+  searchMessages: messageProcedure
+    .input(z.object({ keywords: z.string() }))
+    .query(async ({ input, ctx }) => {
+      return ctx.messageModel.queryByKeyword(input.keywords);
+    }),
+
+  update: messageProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z.object({}).passthrough().partial(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.messageModel.update(input.id, input.value);
+    }),
+
+  updatePluginState: messageProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z.object({}).passthrough(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      return ctx.messageModel.updatePluginState(input.id, input.value);
+    }),
+
+  updateTTS: messageProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z
+          .object({
+            contentMd5: z.string().optional(),
+            fileId: z.string().optional(),
+            voice: z.string().optional(),
+          })
+          .or(z.literal(false)),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      if (input.value === false) {
+        return ctx.messageModel.deleteMessageTTS(input.id);
+      }
+
+      return ctx.messageModel.updateTTS(input.id, input.value);
+    }),
+
+  updateTranslate: messageProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        value: z
+          .object({
+            content: z.string().optional(),
+            from: z.string().optional(),
+            to: z.string(),
+          })
+          .or(z.literal(false)),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      if (input.value === false) {
+        return ctx.messageModel.deleteMessageTranslate(input.id);
+      }
+
+      return ctx.messageModel.updateTranslate(input.id, input.value);
+    }),
+});
+
+export type MessageRouter = typeof messageRouter;