@lobehub/lobehub 2.0.0-next.233 → 2.0.0-next.235

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

@@ -36,7 +36,7 @@ export const klavisRouter = router({
     .mutation(async ({ input, ctx }) => {
       const { serverName, userId, identifier } = input;
 
-      // 创建单个服务器实例
+      // Create a single server instance
       const response = await ctx.klavisClient.mcpServer.createServerInstance({
         serverName: serverName as any,
         userId,
@@ -44,11 +44,11 @@ export const klavisRouter = router({
 
       const { serverUrl, instanceId, oauthUrl } = response;
 
-      // 获取该服务器的工具列表
+      // Get the tool list for this server
       const toolsResponse = await ctx.klavisClient.mcpServer.getTools(serverName as any);
       const tools = toolsResponse.tools || [];
 
-      // 保存到数据库，使用传入的 identifier（格式：小写，空格替换为连字符）
+      // Save to database using the provided identifier (format: lowercase, spaces replaced with hyphens)
       const manifest: LobeChatPluginManifest = {
         api: tools.map((tool: any) => ({
           description: tool.description || '',
@@ -64,8 +64,8 @@ export const klavisRouter = router({
         type: 'default',
       };
 
-      // 保存到数据库，包含 oauthUrl 和 isAuthenticated 状态
-      const isAuthenticated = !oauthUrl; // 如果没有 oauthUrl，说明不需要认证或已认证
+      // Save to database with oauthUrl and isAuthenticated status
+      const isAuthenticated = !oauthUrl; // If there's no oauthUrl, authentication is not required or already authenticated
       await ctx.pluginModel.create({
         customParams: {
           klavis: {
@@ -104,10 +104,10 @@ export const klavisRouter = router({
       }),
     )
     .mutation(async ({ input, ctx }) => {
-      // 调用 Klavis API 删除服务器实例
+      // Call Klavis API to delete server instance
       await ctx.klavisClient.mcpServer.deleteServerInstance(input.instanceId);
 
-      // 从数据库删除（使用 identifier）
+      // Delete from database (using identifier)
       await ctx.pluginModel.delete(input.identifier);
 
       return { success: true };
@@ -200,10 +200,10 @@ export const klavisRouter = router({
       const { identifier, serverName, serverUrl, instanceId, tools, isAuthenticated, oauthUrl } =
         input;
 
-      // 获取现有插件（使用 identifier）
+      // Get existing plugin (using identifier)
       const existingPlugin = await ctx.pluginModel.findById(identifier);
 
-      // 构建包含所有工具的 manifest
+      // Build manifest containing all tools
       const manifest: LobeChatPluginManifest = {
         api: tools.map((tool) => ({
           description: tool.description || '',
@@ -229,7 +229,7 @@ export const klavisRouter = router({
         },
       };
 
-      // 更新或创建插件
+      // Update or create plugin
       if (existingPlugin) {
         await ctx.pluginModel.update(identifier, { customParams, manifest });
       } else {

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

@@ -559,11 +559,11 @@ export const marketRouter = router({
         log('get access token, expiresIn value:', expiresIn);
         log('expiresIn type:', typeof expiresIn);
 
-        const expirationTime = new Date(Date.now() + (expiresIn - 60) * 1000); // 提前 60 秒过期
+        const expirationTime = new Date(Date.now() + (expiresIn - 60) * 1000); // Expire 60 seconds early
 
         log('expirationTime:', expirationTime.toISOString());
 
-        // 设置 HTTP-Only Cookie 存储实际的 access token
+        // Set HTTP-Only Cookie to store the actual access token
         const tokenCookie = serialize('mp_token', accessToken, {
           expires: expirationTime,
           httpOnly: true,
@@ -572,7 +572,7 @@ export const marketRouter = router({
           secure: process.env.NODE_ENV === 'production',
         });
 
-        // 设置客户端可读的状态标记 cookie（不包含实际 token）
+        // Set client-readable status marker cookie (without actual token)
         const statusCookie = serialize('mp_token_status', 'active', {
           expires: expirationTime,
           httpOnly: false,
@@ -581,7 +581,7 @@ export const marketRouter = router({
           secure: process.env.NODE_ENV === 'production',
         });
 
-        // 通过 context 的 resHeaders 设置 Set-Cookie 头
+        // Set Set-Cookie header via context's resHeaders
         ctx.resHeaders?.append('Set-Cookie', tokenCookie);
         ctx.resHeaders?.append('Set-Cookie', statusCookie);
 
@@ -650,7 +650,7 @@ export const marketRouter = router({
         return { success: true };
       } catch (error) {
         console.error('Error reporting call: %O', error);
-        // 不抛出错误，因为上报失败不应影响主流程
+        // Don't throw error, as reporting failure should not affect main flow
         return { success: false };
       }
     }),
@@ -678,7 +678,7 @@ export const marketRouter = router({
         return { success: true };
       } catch (error) {
         log('Error reporting MCP installation result: %O', error);
-        // 不抛出错误，因为上报失败不应影响主流程
+        // Don't throw error, as reporting failure should not affect main flow
         return { success: false };
       }
     }),

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

@@ -75,13 +75,13 @@ export const messageRouter = router({
   createMessage: messageProcedure
     .input(CreateNewMessageParamsSchema)
     .mutation(async ({ input, ctx }) => {
-      // 如果没有 agentId 但有 sessionId，从 sessionId 解析出 agentId
+      // If there's no agentId but has sessionId, resolve agentId from sessionId
       let agentId = input.agentId;
       if (!agentId && input.sessionId) {
         agentId = (await resolveAgentIdFromSession(input.sessionId, ctx.serverDB, ctx.userId))!;
       }
 
-      // 使用解析后的 agentId 创建消息
+      // Create message with the resolved agentId
       return ctx.messageService.createMessage({ ...input, agentId } as any);
     }),
 

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

@@ -65,7 +65,7 @@ export const pluginRouter = router({
       return data.identifier;
     }),
 
-  // TODO: 未来这部分方法也需要使用 authedProcedure
+  // TODO: In the future, this method also needs to use authedProcedure
   getPlugins: publicProcedure.query(async ({ ctx }): Promise<LobeTool[]> => {
     if (!ctx.userId) return [];
 

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

@@ -251,7 +251,7 @@ export const ragEvalRouter = router({
       const isSuccess = records.every((record) => record.status === EvalEvaluationStatus.Success);
 
       if (isSuccess) {
-        // 将结果上传到 S3
+        // Upload results to S3
 
         const evalRecords = records.map((record) => ({
           question: record.question,
@@ -265,7 +265,7 @@ export const ragEvalRouter = router({
 
         await ctx.fileService.uploadContent(path, JSONL.stringify(evalRecords));
 
-        // 保存数据
+        // Save data
         await ctx.evaluationModel.update(input.id, {
           status: EvalEvaluationStatus.Success,
           evalRecordsUrl: await ctx.fileService.getFullFileUrl(path),

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

@@ -49,7 +49,7 @@ export const topicRouter = router({
       ),
     )
     .mutation(async ({ input, ctx }): Promise<BatchTaskResult> => {
-      // 解析每个 topic 的 sessionId
+      // Resolve sessionId for each topic
       const resolvedTopics = await Promise.all(
         input.map(async (item) => {
           const { agentId, ...rest } = item;
@@ -162,7 +162,7 @@ export const topicRouter = router({
         return { items: result.items, total: result.total };
       }
 
-      // 如果提供了 sessionId 但没有 agentId，需要反向查找 agentId
+      // If sessionId is provided but no agentId, need to reverse lookup agentId
       let effectiveAgentId = rest.agentId;
       if (!effectiveAgentId && sessionId) {
         effectiveAgentId = await resolveAgentIdFromSession(sessionId, ctx.serverDB, ctx.userId);
@@ -430,7 +430,7 @@ export const topicRouter = router({
     .mutation(async ({ input, ctx }) => {
       const { agentId, ...restValue } = input.value;
 
-      // 如果提供了 agentId，解析为 sessionId
+      // If agentId is provided, resolve to sessionId
       let resolvedSessionId = restValue.sessionId;
       if (agentId && !resolvedSessionId) {
         const resolved = await resolveContext({ agentId }, ctx.serverDB, ctx.userId);

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

@@ -150,7 +150,7 @@ export const userRouter = router({
       firstName: state.firstName,
       fullName: state.fullName,
 
-      // 有消息，或者创建过助理，则认为有 conversation
+      // Has conversation if there are messages or has created any assistant
       hasConversation: hasAnyMessages || hasExtraSession,
 
       interests: state.interests,
@@ -190,40 +190,40 @@ export const userRouter = router({
   }),
 
   updateAvatar: userProcedure.input(z.string()).mutation(async ({ ctx, input }) => {
-    // 如果是 Base64 数据，需要上传到 S3
+    // If it's Base64 data, need to upload to S3
     if (input.startsWith('data:image')) {
       try {
-        // 提取 mimeType，例如 "image/png"
+        // Extract mimeType, e.g., "image/png"
         const prefix = 'data:';
         const semicolonIndex = input.indexOf(';');
         const mimeType =
           semicolonIndex !== -1 ? input.slice(prefix.length, semicolonIndex) : 'image/png';
         const fileType = mimeType.split('/')[1];
 
-        // 分割字符串，获取 Base64 部分
+        // Split string to get the Base64 part
         const commaIndex = input.indexOf(',');
         if (commaIndex === -1) {
           throw new Error('Invalid Base64 data');
         }
         const base64Data = input.slice(commaIndex + 1);
 
-        // 创建 S3 客户端
+        // Create S3 client
         const s3 = new FileS3();
 
-        // 使用 UUID 生成唯一文件名，防止缓存问题
-        // 获取旧头像 URL, 后面删除该头像
+        // Use UUID to generate unique filename to prevent caching issues
+        // Get old avatar URL for later deletion
         const userState = await ctx.userModel.getUserState(KeyVaultsGateKeeper.getUserKeyVaults);
         const oldAvatarUrl = userState.avatar;
 
         const fileName = `${uuidv4()}.${fileType}`;
         const filePath = `user/avatar/${ctx.userId}/${fileName}`;
 
-        // 将 Base64 数据转换为 Buffer 再上传到 S3
+        // Convert Base64 data to Buffer and upload to S3
         const buffer = Buffer.from(base64Data, 'base64');
 
         await s3.uploadBuffer(filePath, buffer, mimeType);
 
-        // 删除旧头像
+        // Delete old avatar
         if (oldAvatarUrl && oldAvatarUrl.startsWith('/webapi/')) {
           const oldFilePath = oldAvatarUrl.replace('/webapi/', '');
           await s3.deleteFile(oldFilePath);
@@ -239,7 +239,7 @@ export const userRouter = router({
       }
     }
 
-    // 如果不是 Base64 数据，直接使用 URL 更新用户头像
+    // If it's not Base64 data, directly use URL to update user avatar
     return ctx.userModel.updateUser({ avatar: input });
   }),
 

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

@@ -305,11 +305,11 @@ export const userMemoriesRouter = router({
       }
     }),
 
-  // REVIEW：根据当前 topic 直接提取记忆
-  // REVIEW： 我们需要一个既可以 cron 也可以主动用户触发进行「每日/每周/每隔一段时间的」记忆提取/生成的函数实现
-  // REVIEW： 定时任务
-  // 不用 tRPC，直接 server/service
-  // 可以参考 https://github.com/lobehub/lobe-chat-cloud/blob/886ff2fcd44b7b00a3aa8906f84914a6dcaa1815/src/app/(backend)/cron/reset-budgets/route.ts#L214
+  // REVIEW: Extract memories directly from current topic
+  // REVIEW: We need a function implementation that can be triggered both by cron and manually by users for "daily/weekly/periodic" memory extraction/generation
+  // REVIEW: Scheduled task
+  // Don't use tRPC, use server/service directly
+  // Reference: https://github.com/lobehub/lobe-chat-cloud/blob/886ff2fcd44b7b00a3aa8906f84914a6dcaa1815/src/app/(backend)/cron/reset-budgets/route.ts#L214
   reEmbedMemories: memoryProcedure
     .input(reEmbedInputSchema.optional())
     .mutation(async ({ ctx, input }) => {
@@ -740,7 +740,7 @@ export const userMemoriesRouter = router({
     }
   }),
 
-  // REVIEW: 需要实现 tool memory api
+  // REVIEW: Need to implement tool memory api
   toolAddContextMemory: memoryProcedure
     .input(ContextMemoryItemSchema)
     .mutation(async ({ input, ctx }) => {

package/src/server/routers/tools/market.ts

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { type ToolCallContent } from '@/libs/mcp';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase, telemetry } from '@/libs/trpc/lambda/middleware';
+import { marketSDK, requireMarketAuth } from '@/libs/trpc/lambda/middleware/marketSDK';
 import { generateTrustedClientToken, isTrustedClientEnabled } from '@/libs/trusted-client';
 import { FileS3 } from '@/server/modules/S3';
 import { DiscoverService } from '@/server/services/discover';
@@ -41,6 +42,23 @@ const marketToolProcedure = authedProcedure
     });
   });
 
+// ============================== LobeHub Skill Procedures ==============================
+/**
+ * LobeHub Skill procedure with SDK and optional auth
+ * Used for routes that may work without auth (like listing providers)
+ */
+const lobehubSkillBaseProcedure = authedProcedure
+  .use(serverDatabase)
+  .use(telemetry)
+  .use(marketUserInfo)
+  .use(marketSDK);
+
+/**
+ * LobeHub Skill procedure with required auth
+ * Used for routes that require user authentication
+ */
+const lobehubSkillAuthProcedure = lobehubSkillBaseProcedure.use(requireMarketAuth);
+
 // ============================== Schema Definitions ==============================
 
 // Schema for metadata that frontend needs to pass (for cloud MCP reporting)
@@ -269,6 +287,249 @@ export const marketRouter = router({
       }
     }),
 
+  // ============================== LobeHub Skill ==============================
+  /**
+   * Call a LobeHub Skill tool
+   */
+  connectCallTool: lobehubSkillAuthProcedure
+    .input(
+      z.object({
+        args: z.record(z.any()).optional(),
+        provider: z.string(),
+        toolName: z.string(),
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      const { provider, toolName, args } = input;
+      log('connectCallTool: provider=%s, tool=%s', provider, toolName);
+
+      try {
+        const response = await ctx.marketSDK.skills.callTool(provider, {
+          args: args || {},
+          tool: toolName,
+        });
+
+        log('connectCallTool response: %O', response);
+
+        return {
+          data: response.data,
+          success: response.success,
+        };
+      } catch (error) {
+        const errorMessage = (error as Error).message;
+        log('connectCallTool error: %s', errorMessage);
+
+        if (errorMessage.includes('NOT_CONNECTED')) {
+          throw new TRPCError({
+            code: 'UNAUTHORIZED',
+            message: 'Provider not connected. Please authorize first.',
+          });
+        }
+
+        if (errorMessage.includes('TOKEN_EXPIRED')) {
+          throw new TRPCError({
+            code: 'UNAUTHORIZED',
+            message: 'Token expired. Please re-authorize.',
+          });
+        }
+
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to call tool: ${errorMessage}`,
+        });
+      }
+    }),
+
+  /**
+   * Get all connections health status
+   */
+  connectGetAllHealth: lobehubSkillAuthProcedure.query(async ({ ctx }) => {
+    log('connectGetAllHealth');
+
+    try {
+      const response = await ctx.marketSDK.connect.getAllHealth();
+      return {
+        connections: response.connections || [],
+        summary: response.summary,
+      };
+    } catch (error) {
+      log('connectGetAllHealth error: %O', error);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to get connections health: ${(error as Error).message}`,
+      });
+    }
+  }),
+
+  /**
+   * Get authorize URL for a provider
+   * This calls the SDK's authorize method which generates a secure authorization URL
+   */
+  connectGetAuthorizeUrl: lobehubSkillAuthProcedure
+    .input(
+      z.object({
+        provider: z.string(),
+        redirectUri: z.string().optional(),
+        scopes: z.array(z.string()).optional(),
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      log('connectGetAuthorizeUrl: provider=%s', input.provider);
+
+      try {
+        const response = await ctx.marketSDK.connect.authorize(input.provider, {
+          redirect_uri: input.redirectUri,
+          scopes: input.scopes,
+        });
+
+        return {
+          authorizeUrl: response.authorize_url,
+          code: response.code,
+          expiresIn: response.expires_in,
+        };
+      } catch (error) {
+        log('connectGetAuthorizeUrl error: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to get authorize URL: ${(error as Error).message}`,
+        });
+      }
+    }),
+
+  /**
+   * Get connection status for a provider
+   */
+  connectGetStatus: lobehubSkillAuthProcedure
+    .input(z.object({ provider: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('connectGetStatus: provider=%s', input.provider);
+
+      try {
+        const response = await ctx.marketSDK.connect.getStatus(input.provider);
+        return {
+          connected: response.connected,
+          connection: response.connection,
+          icon: (response as any).icon,
+          providerName: (response as any).providerName,
+        };
+      } catch (error) {
+        log('connectGetStatus error: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to get status: ${(error as Error).message}`,
+        });
+      }
+    }),
+
+  /**
+   * List all user connections
+   */
+  connectListConnections: lobehubSkillAuthProcedure.query(async ({ ctx }) => {
+    log('connectListConnections');
+
+    try {
+      const response = await ctx.marketSDK.connect.listConnections();
+      // Debug logging
+      log('connectListConnections raw response: %O', response);
+      log('connectListConnections connections: %O', response.connections);
+      return {
+        connections: response.connections || [],
+      };
+    } catch (error) {
+      log('connectListConnections error: %O', error);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to list connections: ${(error as Error).message}`,
+      });
+    }
+  }),
+
+  /**
+   * List available providers (public, no auth required)
+   */
+  connectListProviders: lobehubSkillBaseProcedure.query(async ({ ctx }) => {
+    log('connectListProviders');
+
+    try {
+      const response = await ctx.marketSDK.skills.listProviders();
+      return {
+        providers: response.providers || [],
+      };
+    } catch (error) {
+      log('connectListProviders error: %O', error);
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to list providers: ${(error as Error).message}`,
+      });
+    }
+  }),
+
+  /**
+   * List tools for a provider
+   */
+  connectListTools: lobehubSkillBaseProcedure
+    .input(z.object({ provider: z.string() }))
+    .query(async ({ input, ctx }) => {
+      log('connectListTools: provider=%s', input.provider);
+
+      try {
+        const response = await ctx.marketSDK.skills.listTools(input.provider);
+        return {
+          provider: input.provider,
+          tools: response.tools || [],
+        };
+      } catch (error) {
+        log('connectListTools error: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to list tools: ${(error as Error).message}`,
+        });
+      }
+    }),
+
+  /**
+   * Refresh token for a provider
+   */
+  connectRefresh: lobehubSkillAuthProcedure
+    .input(z.object({ provider: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      log('connectRefresh: provider=%s', input.provider);
+
+      try {
+        const response = await ctx.marketSDK.connect.refresh(input.provider);
+        return {
+          connection: response.connection,
+          refreshed: response.refreshed,
+        };
+      } catch (error) {
+        log('connectRefresh error: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to refresh token: ${(error as Error).message}`,
+        });
+      }
+    }),
+
+  /**
+   * Revoke connection for a provider
+   */
+  connectRevoke: lobehubSkillAuthProcedure
+    .input(z.object({ provider: z.string() }))
+    .mutation(async ({ input, ctx }) => {
+      log('connectRevoke: provider=%s', input.provider);
+
+      try {
+        await ctx.marketSDK.connect.revoke(input.provider);
+        return { success: true };
+      } catch (error) {
+        log('connectRevoke error: %O', error);
+        throw new TRPCError({
+          code: 'INTERNAL_SERVER_ERROR',
+          message: `Failed to revoke connection: ${(error as Error).message}`,
+        });
+      }
+    }),
+
   /**
    * Export a file from sandbox and upload to S3, then create a persistent file record
    * This combines the previous getExportFileUploadUrl + callCodeInterpreterTool + createFileRecord flow

package/src/server/services/document/index.ts

@@ -100,6 +100,28 @@ export class DocumentService {
     return document;
   }
 
+  /**
+   * Create multiple documents in batch (optimized for folder creation)
+   * Returns array of created documents with same order as input
+   */
+  async createDocuments(
+    documents: Array<{
+      content?: string;
+      editorData: Record<string, any>;
+      fileType?: string;
+      knowledgeBaseId?: string;
+      metadata?: Record<string, any>;
+      parentId?: string;
+      slug?: string;
+      title: string;
+    }>,
+  ): Promise<DocumentItem[]> {
+    // Create all documents in parallel for better performance
+    const results = await Promise.all(documents.map((params) => this.createDocument(params)));
+
+    return results;
+  }
+
   /**
    * Query documents with pagination
    */

package/src/services/document/index.ts

@@ -28,6 +28,10 @@ export class DocumentService {
     return lambdaClient.document.createDocument.mutate(params);
   }
 
+  async createDocuments(documents: CreateDocumentParams[]): Promise<DocumentItem[]> {
+    return lambdaClient.document.createDocuments.mutate({ documents });
+  }
+
   async queryDocuments(params?: {
     current?: number;
     fileTypes?: string[];

package/src/services/upload.ts

@@ -44,6 +44,7 @@ const generateFilePathMetadata = (
 };
 
 interface UploadFileToS3Options {
+  abortController?: AbortController;
   directory?: string;
   filename?: string;
   onNotSupported?: () => void;
@@ -58,13 +59,18 @@ class UploadService {
    */
   uploadFileToS3 = async (
     file: File,
-    { onProgress, directory, pathname }: UploadFileToS3Options,
+    { onProgress, directory, pathname, abortController }: UploadFileToS3Options,
   ): Promise<{ data: FileMetadata; success: boolean }> => {
     // Server-side upload logic
 
     // if is server mode, upload to server s3,
 
-    const data = await this.uploadToServerS3(file, { directory, onProgress, pathname });
+    const data = await this.uploadToServerS3(file, {
+      abortController,
+      directory,
+      onProgress,
+      pathname,
+    });
     return { data, success: true };
   };
 
@@ -129,7 +135,9 @@ class UploadService {
       onProgress,
       directory,
       pathname,
+      abortController,
     }: {
+      abortController?: AbortController;
       directory?: string;
       onProgress?: (status: FileUploadStatus, state: FileUploadState) => void;
       pathname?: string;
@@ -139,6 +147,14 @@ class UploadService {
 
     const { preSignUrl, ...result } = await this.getSignedUploadUrl(file, { directory, pathname });
     let startTime = Date.now();
+
+    // Setup abort listener
+    if (abortController) {
+      abortController.signal.addEventListener('abort', () => {
+        xhr.abort();
+      });
+    }
+
     xhr.upload.addEventListener('progress', (event) => {
       if (event.lengthComputable) {
         const progress = Number(((event.loaded / event.total) * 100).toFixed(1));
@@ -177,6 +193,10 @@ class UploadService {
         if (xhr.status === 0) reject(UPLOAD_NETWORK_ERROR);
         else reject(xhr.statusText);
       });
+      xhr.addEventListener('abort', () => {
+        onProgress?.('cancelled', { progress: 0, restTime: 0, speed: 0 });
+        reject(new Error('Upload cancelled by user'));
+      });
       xhr.send(data);
     });