@lobehub/lobehub 2.0.0-next.313 → 2.0.0-next.315

package/src/app/[variants]/(desktop)/desktop-onboarding/index.tsx

@@ -1,5 +1,6 @@
 'use client';
 
+import { APP_WINDOW_MIN_SIZE } from '@lobechat/desktop-bridge';
 import { Flexbox, Skeleton } from '@lobehub/ui';
 import { Suspense, memo, useCallback, useEffect, useState } from 'react';
 import { useSearchParams } from 'react-router-dom';
@@ -50,12 +51,11 @@ const DesktopOnboardingPage = memo(() => {
 
   // 设置窗口大小和可调整性
   useEffect(() => {
-    const fixedSize = { height: 900, width: 1400 };
+    const minimumSize = { height: 900, width: 1200 };
 
     const applyWindowSettings = async () => {
       try {
-        await electronSystemService.setWindowSize(fixedSize);
-        await electronSystemService.setWindowResizable({ resizable: false });
+        await electronSystemService.setWindowMinimumSize(minimumSize);
       } catch (error) {
         console.error('[DesktopOnboarding] Failed to apply window settings:', error);
       }
@@ -64,7 +64,8 @@ const DesktopOnboardingPage = memo(() => {
     applyWindowSettings();
 
     return () => {
-      electronSystemService.setWindowResizable({ resizable: true }).catch((error) => {
+      // Restore to app-level default minimum size preset
+      electronSystemService.setWindowMinimumSize(APP_WINDOW_MIN_SIZE).catch((error) => {
         console.error('[DesktopOnboarding] Failed to restore window settings:', error);
       });
     };
@@ -127,9 +128,9 @@ const DesktopOnboardingPage = memo(() => {
           // 如果是第4步（LoginStep），完成 onboarding
           setDesktopOnboardingCompleted();
           clearDesktopOnboardingStep(); // Clear persisted step since onboarding is complete
-          // Restore window resizable before hard reload (cleanup won't run due to hard navigation)
+          // Restore window minimum size before hard reload (cleanup won't run due to hard navigation)
           electronSystemService
-            .setWindowResizable({ resizable: true })
+            .setWindowMinimumSize(APP_WINDOW_MIN_SIZE)
             .catch(console.error)
             .finally(() => {
               // Use hard reload instead of SPA navigation to ensure the app boots with the new desktop state.
@@ -196,7 +197,7 @@ const DesktopOnboardingPage = memo(() => {
 
   return (
     <OnboardingContainer>
-      <Flexbox gap={24} style={{ maxWidth: 560, width: '100%' }}>
+      <Flexbox gap={24} style={{ maxWidth: 560, minHeight: '100%', width: '100%' }}>
         <Suspense
           fallback={
             <Flexbox gap={8}>

package/src/app/manifest.ts

@@ -16,7 +16,7 @@ const manifest = async (): Promise<MetadataRoute.Manifest> => {
       ],
       name: 'LobeChat',
       short_name: 'LobeChat',
-      start_url: '/agent',
+      start_url: '/',
       theme_color: '#000000',
     };
   }

package/src/features/Electron/titlebar/NavigationBar.tsx

@@ -53,13 +53,12 @@ const NavigationBar = memo(() => {
   return (
     <Flexbox
       align="center"
-      className={electronStylish.nodrag}
       data-width={leftPanelWidth}
       horizontal
       justify="end"
       style={{ width: `${leftPanelWidth - 12}px` }}
     >
-      <Flexbox align="center" gap={2} horizontal>
+      <Flexbox align="center" className={electronStylish.nodrag} gap={2} horizontal>
         <ActionIcon disabled={!canGoBack} icon={ArrowLeft} onClick={goBack} size="small" />
         <ActionIcon disabled={!canGoForward} icon={ArrowRight} onClick={goForward} size="small" />
         <Popover

package/src/server/manifest.ts

@@ -63,10 +63,10 @@ export class Manifest {
       screenshots: screenshots.map((item) => this._getScreenshot(item)),
       short_name: name,
       splash_pages: null,
-      start_url: '/agent',
+      start_url: '/',
       tab_strip: {
         new_tab_button: {
-          url: '/agent',
+          url: '/',
         },
       },
       theme_color: color,

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

@@ -28,6 +28,7 @@ import {
 import { AgentService } from '@/server/services/agent';
 import { AgentRuntimeService } from '@/server/services/agentRuntime';
 import type { StepLifecycleCallbacks } from '@/server/services/agentRuntime/types';
+import { KlavisService } from '@/server/services/klavis';
 import { MarketService } from '@/server/services/market';
 
 const log = debug('lobe-server:ai-agent-service');
@@ -93,6 +94,7 @@ export class AiAgentService {
   private readonly topicModel: TopicModel;
   private readonly agentRuntimeService: AgentRuntimeService;
   private readonly marketService: MarketService;
+  private readonly klavisService: KlavisService;
 
   constructor(db: LobeChatDatabase, userId: string) {
     this.userId = userId;
@@ -105,6 +107,7 @@ export class AiAgentService {
     this.topicModel = new TopicModel(db, userId);
     this.agentRuntimeService = new AgentRuntimeService(db, userId);
     this.marketService = new MarketService({ userInfo: { userId } });
+    this.klavisService = new KlavisService({ db, userId });
   }
 
   /**
@@ -205,7 +208,16 @@ export class AiAgentService {
     }
     log('execAgent: got %d lobehub skill manifests', lobehubSkillManifests.length);
 
-    // 6. Create tools using Server AgentToolsEngine
+    // 6. Fetch Klavis tool manifests from database
+    let klavisManifests: LobeToolManifest[] = [];
+    try {
+      klavisManifests = await this.klavisService.getKlavisManifests();
+    } catch (error) {
+      log('execAgent: failed to fetch klavis manifests: %O', error);
+    }
+    log('execAgent: got %d klavis manifests', klavisManifests.length);
+
+    // 7. Create tools using Server AgentToolsEngine
     const hasEnabledKnowledgeBases =
       agentConfig.knowledgeBases?.some((kb: { enabled?: boolean | null }) => kb.enabled === true) ??
       false;
@@ -216,7 +228,7 @@ export class AiAgentService {
     };
 
     const toolsEngine = createServerAgentToolsEngine(toolsContext, {
-      additionalManifests: lobehubSkillManifests,
+      additionalManifests: [...lobehubSkillManifests, ...klavisManifests],
       agentConfig: {
         chatConfig: agentConfig.chatConfig ?? undefined,
         plugins: agentConfig.plugins ?? undefined,
@@ -254,15 +266,20 @@ export class AiAgentService {
     for (const manifest of lobehubSkillManifests) {
       toolSourceMap[manifest.identifier] = 'lobehubSkill';
     }
+    // Mark klavis tools
+    for (const manifest of klavisManifests) {
+      toolSourceMap[manifest.identifier] = 'klavis';
+    }
 
     log(
-      'execAgent: generated %d tools from %d configured plugins, %d lobehub skills',
+      'execAgent: generated %d tools from %d configured plugins, %d lobehub skills, %d klavis tools',
       tools?.length ?? 0,
       pluginIds.length,
       lobehubSkillManifests.length,
+      klavisManifests.length,
     );
 
-    // 6. Get existing messages if provided
+    // 8. Get existing messages if provided
     let historyMessages: any[] = [];
     if (existingMessageIds.length > 0) {
       historyMessages = await this.messageModel.query({
@@ -275,7 +292,7 @@ export class AiAgentService {
       }
     }
 
-    // 7. Create user message in database
+    // 9. Create user message in database
     // Include threadId if provided (for SubAgent task execution in isolated Thread)
     const userMessageRecord = await this.messageModel.create({
       agentId: resolvedAgentId,
@@ -286,7 +303,7 @@ export class AiAgentService {
     });
     log('execAgent: created user message %s', userMessageRecord.id);
 
-    // 8. Create assistant message placeholder in database
+    // 10. Create assistant message placeholder in database
     // Include threadId if provided (for SubAgent task execution in isolated Thread)
     const assistantMessageRecord = await this.messageModel.create({
       agentId: resolvedAgentId,
@@ -306,7 +323,7 @@ export class AiAgentService {
     // Combine history messages with user message
     const allMessages = [...historyMessages, userMessage];
 
-    // 9. Process messages using Server ContextEngineering
+    // 11. Process messages using Server ContextEngineering
     const processedMessages = await serverMessagesEngine({
       capabilities: {
         isCanUseFC: isModelSupportToolUse,
@@ -341,11 +358,11 @@ export class AiAgentService {
 
     log('execAgent: processed %d messages', processedMessages.length);
 
-    // 10. Generate operation ID: agt_{timestamp}_{agentId}_{topicId}_{random}
+    // 12. Generate operation ID: agt_{timestamp}_{agentId}_{topicId}_{random}
     const timestamp = Date.now();
     const operationId = `op_${timestamp}_${resolvedAgentId}_${topicId}_${nanoid(8)}`;
 
-    // 11. Create initial context
+    // 13. Create initial context
     const initialContext: AgentRuntimeContext = {
       payload: {
         // Pass assistant message ID so agent runtime knows which message to update
@@ -366,7 +383,7 @@ export class AiAgentService {
       },
     };
 
-    // 12. Log final operation parameters summary
+    // 14. Log final operation parameters summary
     log(
       'execAgent: creating operation %s with params: model=%s, provider=%s, tools=%d, messages=%d, manifests=%d',
       operationId,
@@ -377,7 +394,7 @@ export class AiAgentService {
       Object.keys(toolManifestMap).length,
     );
 
-    // 13. Create operation using AgentRuntimeService
+    // 15. Create operation using AgentRuntimeService
     // Wrap in try-catch to handle operation startup failures (e.g., QStash unavailable)
     // If createOperation fails, we still have valid messages that need error info
     try {

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

@@ -0,0 +1,228 @@
+import type { LobeToolManifest } from '@lobechat/context-engine';
+import type { LobeChatDatabase } from '@lobechat/database';
+import debug from 'debug';
+
+import { PluginModel } from '@/database/models/plugin';
+import { getKlavisClient, isKlavisClientAvailable } from '@/libs/klavis';
+import { type ToolExecutionResult } from '@/server/services/toolExecution/types';
+
+const log = debug('lobe-server:klavis-service');
+
+export interface KlavisToolExecuteParams {
+  args: Record<string, any>;
+  /** Tool identifier (same as Klavis server identifier, e.g., 'google-calendar') */
+  identifier: string;
+  toolName: string;
+}
+
+export interface KlavisServiceOptions {
+  db?: LobeChatDatabase;
+  userId?: string;
+}
+
+/**
+ * Klavis Service
+ *
+ * Provides a unified interface to Klavis Client with business logic encapsulation.
+ * This service wraps Klavis Client methods to execute tools and fetch manifests.
+ *
+ * Usage:
+ * ```typescript
+ * // With database and userId (for manifest fetching)
+ * const service = new KlavisService({ db, userId });
+ * await service.executeKlavisTool({ identifier, toolName, args });
+ *
+ * // Without database (for tool execution only if you have serverUrl)
+ * const service = new KlavisService();
+ * ```
+ */
+export class KlavisService {
+  private db?: LobeChatDatabase;
+  private userId?: string;
+  private pluginModel?: PluginModel;
+
+  constructor(options: KlavisServiceOptions = {}) {
+    const { db, userId } = options;
+
+    this.db = db;
+    this.userId = userId;
+
+    if (db && userId) {
+      this.pluginModel = new PluginModel(db, userId);
+    }
+
+    log(
+      'KlavisService initialized: hasDB=%s, hasUserId=%s, isClientAvailable=%s',
+      !!db,
+      !!userId,
+      isKlavisClientAvailable(),
+    );
+  }
+
+  /**
+   * Execute a Klavis tool
+   * @param params - Tool execution parameters
+   * @returns Tool execution result
+   */
+  async executeKlavisTool(params: KlavisToolExecuteParams): Promise<ToolExecutionResult> {
+    const { identifier, toolName, args } = params;
+
+    log('executeKlavisTool: %s/%s with args: %O', identifier, toolName, args);
+
+    // Check if Klavis client is available
+    if (!isKlavisClientAvailable()) {
+      return {
+        content: 'Klavis service is not configured on server',
+        error: { code: 'KLAVIS_NOT_CONFIGURED', message: 'Klavis API key not found' },
+        success: false,
+      };
+    }
+
+    // Get serverUrl from plugin database
+    if (!this.pluginModel) {
+      return {
+        content: 'Klavis service is not properly initialized',
+        error: {
+          code: 'KLAVIS_NOT_INITIALIZED',
+          message: 'Database and userId are required for Klavis tool execution',
+        },
+        success: false,
+      };
+    }
+
+    try {
+      // Get plugin from database to retrieve serverUrl
+      const plugin = await this.pluginModel.findById(identifier);
+      if (!plugin) {
+        return {
+          content: `Klavis server "${identifier}" not found in database`,
+          error: { code: 'KLAVIS_SERVER_NOT_FOUND', message: `Server ${identifier} not found` },
+          success: false,
+        };
+      }
+
+      const klavisParams = plugin.customParams?.klavis;
+      if (!klavisParams || !klavisParams.serverUrl) {
+        return {
+          content: `Klavis configuration not found for server "${identifier}"`,
+          error: {
+            code: 'KLAVIS_CONFIG_NOT_FOUND',
+            message: `Klavis configuration missing for ${identifier}`,
+          },
+          success: false,
+        };
+      }
+
+      const { serverUrl } = klavisParams;
+
+      log('executeKlavisTool: calling Klavis API with serverUrl=%s', serverUrl);
+
+      // Call Klavis client
+      const klavisClient = getKlavisClient();
+      const response = await klavisClient.mcpServer.callTools({
+        serverUrl,
+        toolArgs: args,
+        toolName,
+      });
+
+      log('executeKlavisTool: response: %O', response);
+
+      // Handle error case
+      if (!response.success || !response.result) {
+        return {
+          content: response.error || 'Unknown error',
+          error: { code: 'KLAVIS_EXECUTION_ERROR', message: response.error || 'Unknown error' },
+          success: false,
+        };
+      }
+
+      // Process the response
+      const content = response.result.content || [];
+      const isError = response.result.isError || false;
+
+      // Convert content array to string
+      let resultContent = '';
+      if (Array.isArray(content)) {
+        resultContent = content
+          .map((item: any) => {
+            if (typeof item === 'string') return item;
+            if (item.type === 'text' && item.text) return item.text;
+            return JSON.stringify(item);
+          })
+          .join('\n');
+      } else if (typeof content === 'string') {
+        resultContent = content;
+      } else {
+        resultContent = JSON.stringify(content);
+      }
+
+      return {
+        content: resultContent,
+        success: !isError,
+      };
+    } catch (error) {
+      const err = error as Error;
+      console.error('KlavisService.executeKlavisTool error %s/%s: %O', identifier, toolName, err);
+
+      return {
+        content: err.message,
+        error: { code: 'KLAVIS_ERROR', message: err.message },
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Fetch Klavis tool manifests from database
+   * Gets user's connected Klavis servers and builds tool manifests for agent execution
+   *
+   * @returns Array of tool manifests for connected Klavis servers
+   */
+  async getKlavisManifests(): Promise<LobeToolManifest[]> {
+    if (!this.pluginModel) {
+      log('getKlavisManifests: pluginModel not available, returning empty array');
+      return [];
+    }
+
+    try {
+      // Get all plugins from database
+      const allPlugins = await this.pluginModel.query();
+
+      // Filter plugins that have klavis customParams and are authenticated
+      const klavisPlugins = allPlugins.filter(
+        (plugin) => plugin.customParams?.klavis?.isAuthenticated === true,
+      );
+
+      log('getKlavisManifests: found %d authenticated Klavis plugins', klavisPlugins.length);
+
+      // Convert to LobeToolManifest format
+      const manifests: LobeToolManifest[] = klavisPlugins
+        .map((plugin) => {
+          if (!plugin.manifest) return null;
+
+          return {
+            api: plugin.manifest.api || [],
+            author: 'Klavis',
+            homepage: 'https://klavis.ai',
+            identifier: plugin.identifier,
+            meta: plugin.manifest.meta || {
+              avatar: '☁️',
+              description: `Klavis MCP Server: ${plugin.customParams?.klavis?.serverName}`,
+              tags: ['klavis', 'mcp'],
+              title: plugin.customParams?.klavis?.serverName || plugin.identifier,
+            },
+            type: 'builtin',
+            version: '1.0.0',
+          };
+        })
+        .filter(Boolean) as LobeToolManifest[];
+
+      log('getKlavisManifests: returning %d manifests', manifests.length);
+
+      return manifests;
+    } catch (error) {
+      console.error('KlavisService.getKlavisManifests error: %O', error);
+      return [];
+    }
+  }
+}

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

@@ -280,6 +280,19 @@ export class MarketService {
     return this.market.plugins.callCloudGateway(params, options);
   }
 
+  /**
+   * Export file from sandbox to upload URL
+   */
+  async exportFile(params: { path: string; topicId: string; uploadUrl: string; userId: string }) {
+    const { path, uploadUrl, topicId, userId } = params;
+
+    return this.market.plugins.runBuildInTool(
+      'exportFile',
+      { path, uploadUrl },
+      { topicId, userId },
+    );
+  }
+
   /**
    * Get plugin manifest
    */

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

@@ -1,16 +1,20 @@
-import { type CodeInterpreterToolName } from '@lobehub/market-sdk';
 import {
   type ISandboxService,
   type SandboxCallToolResult,
   type SandboxExportFileResult,
 } from '@lobechat/builtin-tool-cloud-sandbox';
+import { type CodeInterpreterToolName } from '@lobehub/market-sdk';
 import debug from 'debug';
+import { sha256 } from 'js-sha256';
 
+import { FileS3 } from '@/server/modules/S3';
+import { type FileService } from '@/server/services/file';
 import { MarketService } from '@/server/services/market';
 
 const log = debug('lobe-server:sandbox-service');
 
 export interface ServerSandboxServiceOptions {
+  fileService: FileService;
   marketService: MarketService;
   topicId: string;
   userId: string;
@@ -28,11 +32,13 @@ export interface ServerSandboxServiceOptions {
  * - MarketService handles authentication via trustedClientToken
  */
 export class ServerSandboxService implements ISandboxService {
+  private fileService: FileService;
   private marketService: MarketService;
   private topicId: string;
   private userId: string;
 
   constructor(options: ServerSandboxServiceOptions) {
+    this.fileService = options.fileService;
     this.marketService = options.marketService;
     this.topicId = options.topicId;
     this.userId = options.userId;
@@ -45,11 +51,12 @@ export class ServerSandboxService implements ISandboxService {
     log('Calling sandbox tool: %s with params: %O, topicId: %s', toolName, params, this.topicId);
 
     try {
-      const response = await this.marketService.getSDK().plugins.runBuildInTool(
-        toolName as CodeInterpreterToolName,
-        params as any,
-        { topicId: this.topicId, userId: this.userId },
-      );
+      const response = await this.marketService
+        .getSDK()
+        .plugins.runBuildInTool(toolName as CodeInterpreterToolName, params as any, {
+          topicId: this.topicId,
+          userId: this.userId,
+        });
 
       log('Sandbox tool %s response: %O', toolName, response);
 
@@ -86,26 +93,85 @@ export class ServerSandboxService implements ISandboxService {
   }
 
   /**
-   * Export and upload a file from sandbox
+   * Export and upload a file from sandbox to S3
    *
-   * Note: This is a simplified version for server-side use.
-   * The full implementation with S3 upload is in the tRPC router.
+   * Steps:
+   * 1. Generate S3 pre-signed upload URL
+   * 2. Call sandbox exportFile tool to upload file
+   * 3. Verify upload success and get metadata
+   * 4. Create persistent file record
    */
   async exportAndUploadFile(path: string, filename: string): Promise<SandboxExportFileResult> {
     log('Exporting file: %s from path: %s, topicId: %s', filename, path, this.topicId);
 
-    // For server-side, we need to call the exportFile tool
-    // The full S3 upload logic should be handled separately
-    // This is a basic implementation that can be extended
-
     try {
+      const s3 = new FileS3();
+
+      // Use date-based sharding for privacy compliance (GDPR, CCPA)
+      const today = new Date().toISOString().split('T')[0];
+
+      // Generate a unique key for the exported file
+      const key = `code-interpreter-exports/${today}/${this.topicId}/${filename}`;
+
+      // Step 1: Generate pre-signed upload URL
+      const uploadUrl = await s3.createPreSignedUrl(key);
+      log('Generated upload URL for key: %s', key);
+
+      // Step 2: Call sandbox's exportFile tool with the upload URL
+      const response = await this.marketService.exportFile({
+        path,
+        topicId: this.topicId,
+        uploadUrl,
+        userId: this.userId,
+      });
+
+      log('Sandbox exportFile response: %O', response);
+
+      if (!response.success) {
+        return {
+          error: { message: response.error?.message || 'Failed to export file from sandbox' },
+          filename,
+          success: false,
+        };
+      }
+
+      const result = response.data?.result;
+      const uploadSuccess = result?.success !== false;
+
+      if (!uploadSuccess) {
+        return {
+          error: { message: result?.error || 'Failed to upload file from sandbox' },
+          filename,
+          success: false,
+        };
+      }
+
+      // Step 3: Get file metadata from S3 to verify upload and get actual size
+      const metadata = await s3.getFileMetadata(key);
+      const fileSize = metadata.contentLength;
+      const mimeType = metadata.contentType || result?.mimeType || 'application/octet-stream';
+
+      // Step 4: Create persistent file record using FileService
+      // Generate a simple hash from the key (since we don't have the actual file content)
+      const fileHash = sha256(key + Date.now().toString());
+
+      const { fileId, url } = await this.fileService.createFileRecord({
+        fileHash,
+        fileType: mimeType,
+        name: filename,
+        size: fileSize,
+        url: key, // Store S3 key
+      });
+
+      log('Created file record: fileId=%s, url=%s', fileId, url);
+
       return {
-        error: {
-          message:
-            'Server-side file export not fully implemented. Use tRPC endpoint for file exports.',
-        },
+        fileId,
         filename,
-        success: false,
+        mimeType,
+        size: fileSize,
+        success: true,
+        url, // This is the permanent /f/:id URL
       };
     } catch (error) {
       log('Error exporting file: %O', error);

package/src/server/services/toolExecution/builtin.ts

@@ -3,6 +3,7 @@ import { type ChatToolPayload } from '@lobechat/types';
 import { safeParseJSON } from '@lobechat/utils';
 import debug from 'debug';
 
+import { KlavisService } from '@/server/services/klavis';
 import { MarketService } from '@/server/services/market';
 
 import { getServerRuntime, hasServerRuntime } from './serverRuntimes';
@@ -12,9 +13,11 @@ const log = debug('lobe-server:builtin-tools-executor');
 
 export class BuiltinToolsExecutor implements IToolExecutor {
   private marketService: MarketService;
+  private klavisService: KlavisService;
 
   constructor(db: LobeChatDatabase, userId: string) {
     this.marketService = new MarketService({ userInfo: { userId } });
+    this.klavisService = new KlavisService({ db, userId });
   }
 
   async execute(
@@ -41,6 +44,15 @@ export class BuiltinToolsExecutor implements IToolExecutor {
       });
     }
 
+    // Route Klavis tools to KlavisService
+    if (source === 'klavis') {
+      return this.klavisService.executeKlavisTool({
+        args,
+        identifier,
+        toolName: apiName,
+      });
+    }
+
     // Use server runtime registry (handles both pre-instantiated and per-request runtimes)
     if (!hasServerRuntime(identifier)) {
       throw new Error(`Builtin tool "${identifier}" is not implemented`);