@lobehub/lobehub 2.0.0-next.232 → 2.0.0-next.234

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);
     });
 

package/src/store/chat/slices/plugin/actions/internals.ts

@@ -6,7 +6,11 @@ import { type StateCreator } from 'zustand/vanilla';
 
 import { type ChatStore } from '@/store/chat/store';
 import { useToolStore } from '@/store/tool';
-import { klavisStoreSelectors, pluginSelectors } from '@/store/tool/selectors';
+import {
+  klavisStoreSelectors,
+  lobehubSkillStoreSelectors,
+  pluginSelectors,
+} from '@/store/tool/selectors';
 import { builtinTools } from '@/tools';
 
 /**
@@ -34,7 +38,7 @@ export const pluginInternals: StateCreator<
     const manifests: Record<string, LobeChatPluginManifest> = {};
 
     // Track source for each identifier
-    const sourceMap: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis'> = {};
+    const sourceMap: Record<string, 'builtin' | 'plugin' | 'mcp' | 'klavis' | 'lobehubSkill'> = {};
 
     // Get all installed plugins
     const installedPlugins = pluginSelectors.installedPlugins(toolStoreState);
@@ -63,6 +67,15 @@ export const pluginInternals: StateCreator<
       }
     }
 
+    // Get all LobeHub Skill tools
+    const lobehubSkillTools = lobehubSkillStoreSelectors.lobehubSkillAsLobeTools(toolStoreState);
+    for (const tool of lobehubSkillTools) {
+      if (tool.manifest) {
+        manifests[tool.identifier] = tool.manifest as LobeChatPluginManifest;
+        sourceMap[tool.identifier] = 'lobehubSkill';
+      }
+    }
+
     // Resolve tool calls and add source field
     const resolved = toolNameResolver.resolve(toolCalls, manifests);
     return resolved.map((payload) => ({

package/src/store/chat/slices/plugin/actions/pluginTypes.ts

@@ -60,6 +60,14 @@ export interface PluginTypesAction {
    */
   invokeKlavisTypePlugin: (id: string, payload: ChatToolPayload) => Promise<string | undefined>;
 
+  /**
+   * Invoke LobeHub Skill type plugin
+   */
+  invokeLobehubSkillTypePlugin: (
+    id: string,
+    payload: ChatToolPayload,
+  ) => Promise<string | undefined>;
+
   /**
    * Invoke markdown type plugin
    */
@@ -93,6 +101,11 @@ export const pluginTypes: StateCreator<
       return await get().invokeKlavisTypePlugin(id, payload);
     }
 
+    // Check if this is a LobeHub Skill tool by source field
+    if (payload.source === 'lobehubSkill') {
+      return await get().invokeLobehubSkillTypePlugin(id, payload);
+    }
+
     // Check if this is Cloud Code Interpreter - route to specific handler
     if (payload.identifier === CloudSandboxIdentifier) {
       return await get().invokeCloudCodeInterpreterTool(id, payload);
@@ -439,6 +452,97 @@ export const pluginTypes: StateCreator<
     return data.content;
   },
 
+  invokeLobehubSkillTypePlugin: async (id, payload) => {
+    let data: MCPToolCallResult | undefined;
+
+    // Get message to extract sessionId/topicId
+    const message = dbMessageSelectors.getDbMessageById(id)(get());
+
+    // Get abort controller from operation
+    const operationId = get().messageOperationMap[id];
+    const operation = operationId ? get().operations[operationId] : undefined;
+    const abortController = operation?.abortController;
+
+    log(
+      '[invokeLobehubSkillTypePlugin] messageId=%s, tool=%s, operationId=%s, aborted=%s',
+      id,
+      payload.apiName,
+      operationId,
+      abortController?.signal.aborted,
+    );
+
+    try {
+      // payload.identifier is the provider id (e.g., 'linear', 'microsoft')
+      const provider = payload.identifier;
+
+      // Parse arguments
+      const args = safeParseJSON(payload.arguments) || {};
+
+      // Call LobeHub Skill tool via store action
+      const result = await useToolStore.getState().callLobehubSkillTool({
+        args,
+        provider,
+        toolName: payload.apiName,
+      });
+
+      if (!result.success) {
+        throw new Error(result.error || 'LobeHub Skill tool execution failed');
+      }
+
+      // Convert to MCPToolCallResult format
+      const content = typeof result.data === 'string' ? result.data : JSON.stringify(result.data);
+      data = {
+        content,
+        error: undefined,
+        state: { content: [{ text: content, type: 'text' }] },
+        success: true,
+      };
+    } catch (error) {
+      console.error('[invokeLobehubSkillTypePlugin] Error:', error);
+
+      // ignore the aborted request error
+      const err = error as Error;
+      if (err.message.includes('aborted')) {
+        log(
+          '[invokeLobehubSkillTypePlugin] Request aborted: messageId=%s, tool=%s',
+          id,
+          payload.apiName,
+        );
+      } else {
+        const result = await messageService.updateMessageError(id, error as any, {
+          agentId: message?.agentId,
+          topicId: message?.topicId,
+        });
+        if (result?.success && result.messages) {
+          get().replaceMessages(result.messages, {
+            context: {
+              agentId: message?.agentId,
+              topicId: message?.topicId,
+            },
+          });
+        }
+      }
+    }
+
+    // If error occurred, exit
+    if (!data) return;
+
+    const context = operationId ? { operationId } : undefined;
+
+    // Use optimisticUpdateToolMessage to update content and state/error in a single call
+    await get().optimisticUpdateToolMessage(
+      id,
+      {
+        content: data.content,
+        pluginError: data.success ? undefined : data.error,
+        pluginState: data.success ? data.state : undefined,
+      },
+      context,
+    );
+
+    return data.content;
+  },
+
   invokeMarkdownTypePlugin: async (id, payload) => {
     const { internal_callPluginApi } = get();
 

package/src/store/file/slices/fileManager/action.test.ts

@@ -278,11 +278,14 @@ describe('FileManagerActions', () => {
       // Should only dispatch for the valid file
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: [{ file: validFile, id: validFile.name, status: 'pending' }],
+        files: [
+          expect.objectContaining({ file: validFile, id: validFile.name, status: 'pending' }),
+        ],
         type: 'addFiles',
       });
       expect(uploadSpy).toHaveBeenCalledTimes(1);
       expect(uploadSpy).toHaveBeenCalledWith({
+        abortController: expect.any(AbortController),
         file: validFile,
         knowledgeBaseId: undefined,
         onStatusUpdate: expect.any(Function),
@@ -308,6 +311,7 @@ describe('FileManagerActions', () => {
       });
 
       expect(uploadSpy).toHaveBeenCalledWith({
+        abortController: expect.any(AbortController),
         file,
         knowledgeBaseId: 'kb-123',
         onStatusUpdate: expect.any(Function),
@@ -502,7 +506,9 @@ describe('FileManagerActions', () => {
       // Should upload extracted files
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: extractedFiles.map((file) => ({ file, id: file.name, status: 'pending' })),
+        files: extractedFiles.map((file) =>
+          expect.objectContaining({ file, id: file.name, status: 'pending' }),
+        ),
         type: 'addFiles',
       });
     });
@@ -532,7 +538,7 @@ describe('FileManagerActions', () => {
       // Should fallback to uploading the ZIP file itself
       expect(dispatchSpy).toHaveBeenCalledWith({
         atStart: true,
-        files: [{ file: zipFile, id: zipFile.name, status: 'pending' }],
+        files: [expect.objectContaining({ file: zipFile, id: zipFile.name, status: 'pending' })],
         type: 'addFiles',
       });
     });