@lobehub/lobehub 2.0.0-next.312 → 2.0.0-next.314

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

@@ -0,0 +1,186 @@
+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;
+}
+
+/**
+ * Server-side Sandbox Service
+ *
+ * This service implements ISandboxService for server-side execution.
+ * Context (topicId, userId) is bound at construction time.
+ * It uses MarketService to call sandbox tools.
+ *
+ * Usage:
+ * - Used by BuiltinToolsExecutor when executing CloudSandbox tools on server
+ * - 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;
+  }
+
+  /**
+   * Call a sandbox tool via MarketService
+   */
+  async callTool(toolName: string, params: Record<string, any>): Promise<SandboxCallToolResult> {
+    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,
+        });
+
+      log('Sandbox tool %s response: %O', toolName, response);
+
+      if (!response.success) {
+        return {
+          error: {
+            message: response.error?.message || 'Unknown error',
+            name: response.error?.code,
+          },
+          result: null,
+          sessionExpiredAndRecreated: false,
+          success: false,
+        };
+      }
+
+      return {
+        result: response.data?.result,
+        sessionExpiredAndRecreated: response.data?.sessionExpiredAndRecreated || false,
+        success: true,
+      };
+    } catch (error) {
+      log('Error calling sandbox tool %s: %O', toolName, error);
+
+      return {
+        error: {
+          message: (error as Error).message,
+          name: (error as Error).name,
+        },
+        result: null,
+        sessionExpiredAndRecreated: false,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Export and upload a file from sandbox to S3
+   *
+   * 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);
+
+    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 {
+        fileId,
+        filename,
+        mimeType,
+        size: fileSize,
+        success: true,
+        url, // This is the permanent /f/:id URL
+      };
+    } catch (error) {
+      log('Error exporting file: %O', error);
+
+      return {
+        error: { message: (error as Error).message },
+        filename,
+        success: false,
+      };
+    }
+  }
+}

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

@@ -1,28 +1,26 @@
-import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
-import { WebBrowsingExecutionRuntime } from '@lobechat/builtin-tool-web-browsing/executionRuntime';
 import { type LobeChatDatabase } from '@lobechat/database';
 import { type ChatToolPayload } from '@lobechat/types';
 import { safeParseJSON } from '@lobechat/utils';
 import debug from 'debug';
 
 import { MarketService } from '@/server/services/market';
-import { SearchService } from '@/server/services/search';
 
-import { type IToolExecutor, type ToolExecutionResult } from './types';
+import { getServerRuntime, hasServerRuntime } from './serverRuntimes';
+import { type IToolExecutor, type ToolExecutionContext, type ToolExecutionResult } from './types';
 
 const log = debug('lobe-server:builtin-tools-executor');
 
-const BuiltinToolServerRuntimes: Record<string, any> = {
-  [WebBrowsingManifest.identifier]: WebBrowsingExecutionRuntime,
-};
-
 export class BuiltinToolsExecutor implements IToolExecutor {
   private marketService: MarketService;
 
   constructor(db: LobeChatDatabase, userId: string) {
     this.marketService = new MarketService({ userInfo: { userId } });
   }
-  async execute(payload: ChatToolPayload): Promise<ToolExecutionResult> {
+
+  async execute(
+    payload: ChatToolPayload,
+    context: ToolExecutionContext,
+  ): Promise<ToolExecutionResult> {
     const { identifier, apiName, arguments: argsStr, source } = payload;
     const args = safeParseJSON(argsStr) || {};
 
@@ -43,19 +41,15 @@ export class BuiltinToolsExecutor implements IToolExecutor {
       });
     }
 
-    // Default: original builtin runtime logic
-    const ServerRuntime = BuiltinToolServerRuntimes[identifier];
-
-    if (!ServerRuntime) {
+    // Use server runtime registry (handles both pre-instantiated and per-request runtimes)
+    if (!hasServerRuntime(identifier)) {
       throw new Error(`Builtin tool "${identifier}" is not implemented`);
     }
 
-    const runtime = new ServerRuntime({
-      searchService: new SearchService(),
-    });
+    const runtime = getServerRuntime(identifier, context);
 
     if (!runtime[apiName]) {
-      throw new Error(`Builtin tool ${identifier} 's ${apiName} is not implemented`);
+      throw new Error(`Builtin tool ${identifier}'s ${apiName} is not implemented`);
     }
 
     try {
@@ -64,7 +58,7 @@ export class BuiltinToolsExecutor implements IToolExecutor {
       const error = e as Error;
       console.error('Error executing builtin tool %s:%s: %O', identifier, apiName, error);
 
-      return { content: error.message, error: error, success: false };
+      return { content: error.message, error, success: false };
     }
   }
 }

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

@@ -47,7 +47,7 @@ export class ToolExecutionService {
       let data: ToolExecutionResult;
       switch (typeStr) {
         case 'builtin': {
-          data = await this.builtinToolsExecutor.execute(payload);
+          data = await this.builtinToolsExecutor.execute(payload, context);
           break;
         }
 

package/src/server/services/toolExecution/serverRuntimes/cloudSandbox.ts

@@ -0,0 +1,38 @@
+import {
+  CloudSandboxExecutionRuntime,
+  CloudSandboxIdentifier,
+} from '@lobechat/builtin-tool-cloud-sandbox';
+
+import { FileService } from '@/server/services/file';
+import { MarketService } from '@/server/services/market';
+import { ServerSandboxService } from '@/server/services/sandbox';
+
+import { type ServerRuntimeRegistration } from './types';
+
+/**
+ * CloudSandbox Server Runtime
+ * Per-request runtime (needs topicId, userId)
+ */
+export const cloudSandboxRuntime: ServerRuntimeRegistration = {
+  factory: (context) => {
+    if (!context.userId || !context.topicId) {
+      throw new Error('userId and topicId are required for Cloud Sandbox execution');
+    }
+
+    if (!context.serverDB) {
+      throw new Error('serverDB is required for Cloud Sandbox execution');
+    }
+
+    const marketService = new MarketService({ userInfo: { userId: context.userId } });
+    const fileService = new FileService(context.serverDB, context.userId);
+    const sandboxService = new ServerSandboxService({
+      fileService,
+      marketService,
+      topicId: context.topicId,
+      userId: context.userId,
+    });
+
+    return new CloudSandboxExecutionRuntime(sandboxService);
+  },
+  identifier: CloudSandboxIdentifier,
+};

package/src/server/services/toolExecution/serverRuntimes/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Server Runtime Registry
+ *
+ * Central registry for all builtin tool server runtimes.
+ * Uses factory functions to support both:
+ * - Pre-instantiated runtimes (e.g., WebBrowsing - no per-request context needed)
+ * - Per-request runtimes (e.g., CloudSandbox - needs topicId, userId)
+ */
+import { type ToolExecutionContext } from '../types';
+import { cloudSandboxRuntime } from './cloudSandbox';
+import { type ServerRuntimeFactory, type ServerRuntimeRegistration } from './types';
+import { webBrowsingRuntime } from './webBrowsing';
+
+/**
+ * Registry of server runtime factories by identifier
+ */
+const serverRuntimeFactories = new Map<string, ServerRuntimeFactory>();
+
+/**
+ * Register server runtimes
+ */
+const registerRuntimes = (runtimes: ServerRuntimeRegistration[]) => {
+  for (const runtime of runtimes) {
+    serverRuntimeFactories.set(runtime.identifier, runtime.factory);
+  }
+};
+
+// Register all server runtimes
+registerRuntimes([webBrowsingRuntime, cloudSandboxRuntime]);
+
+// ==================== Registry API ====================
+
+/**
+ * Get a server runtime by identifier
+ * @param identifier - The tool identifier
+ * @param context - Execution context (required for per-request runtimes)
+ */
+export const getServerRuntime = (identifier: string, context: ToolExecutionContext): any => {
+  const factory = serverRuntimeFactories.get(identifier);
+  return factory?.(context);
+};
+
+/**
+ * Check if a server runtime exists for the given identifier
+ */
+export const hasServerRuntime = (identifier: string): boolean => {
+  return serverRuntimeFactories.has(identifier);
+};
+
+/**
+ * Get all registered server runtime identifiers
+ */
+export const getServerRuntimeIdentifiers = (): string[] => {
+  return Array.from(serverRuntimeFactories.keys());
+};

package/src/server/services/toolExecution/serverRuntimes/types.ts

@@ -0,0 +1,14 @@
+import { type ToolExecutionContext } from '../types';
+
+/**
+ * Factory function type for creating server runtimes
+ */
+export type ServerRuntimeFactory = (context: ToolExecutionContext) => any;
+
+/**
+ * Server runtime registration object
+ */
+export interface ServerRuntimeRegistration {
+  factory: ServerRuntimeFactory;
+  identifier: string;
+}

package/src/server/services/toolExecution/serverRuntimes/webBrowsing.ts

@@ -0,0 +1,20 @@
+import { WebBrowsingManifest } from '@lobechat/builtin-tool-web-browsing';
+import { WebBrowsingExecutionRuntime } from '@lobechat/builtin-tool-web-browsing/executionRuntime';
+
+import { SearchService } from '@/server/services/search';
+
+import { type ServerRuntimeRegistration } from './types';
+
+// Pre-instantiated (no per-request context needed)
+const runtime = new WebBrowsingExecutionRuntime({
+  searchService: new SearchService(),
+});
+
+/**
+ * WebBrowsing Server Runtime
+ * Pre-instantiated runtime (no per-request context needed)
+ */
+export const webBrowsingRuntime: ServerRuntimeRegistration = {
+  factory: () => runtime,
+  identifier: WebBrowsingManifest.identifier,
+};

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

@@ -6,6 +6,8 @@ export interface ToolExecutionContext {
   /** Server database for LobeHub Skills execution */
   serverDB?: LobeChatDatabase;
   toolManifestMap: Record<string, LobeToolManifest>;
+  /** Topic ID for sandbox session management */
+  topicId?: string;
   userId?: string;
 }
 

package/src/services/{codeInterpreter.ts → cloudSandbox.ts}

@@ -6,9 +6,9 @@ import type {
   ExportAndUploadFileResult,
 } from '@/server/routers/tools/market';
 
-class CodeInterpreterService {
+class CloudSandboxService {
   /**
-   * Call a cloud code interpreter tool
+   * Call a cloud sandbox tool
    * @param toolName - The name of the tool to call (e.g., 'runCommand', 'writeLocalFile')
    * @param params - The parameters for the tool
    * @param context - Session context containing userId and topicId for isolation
@@ -51,4 +51,4 @@ class CodeInterpreterService {
   }
 }
 
-export const codeInterpreterService = new CodeInterpreterService();
+export const cloudSandboxService = new CloudSandboxService();

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,5 @@
 import { type DataSyncConfig, type MarketAuthorizationParams } from '@lobechat/electron-client-ipc';
+
 import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class RemoteServerService {
@@ -36,6 +37,13 @@ class RemoteServerService {
   requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
     return ensureElectronIpc().auth.requestMarketAuthorization(params);
   };
+
+  /**
+   * Cancel authorization
+   */
+  cancelAuthorization = async () => {
+    return ensureElectronIpc().auth.cancelAuthorization();
+  };
 }
 
 export const remoteServerService = new RemoteServerService();

package/src/services/electron/system.ts

@@ -1,6 +1,6 @@
 import type {
   ElectronAppState,
-  WindowResizableParams,
+  WindowMinimumSizeParams,
   WindowSizeParams,
 } from '@lobechat/electron-client-ipc';
 
@@ -36,14 +36,14 @@ class ElectronSystemService {
     return this.ipc.windows.minimizeWindow();
   }
 
-  async setWindowResizable(params: WindowResizableParams): Promise<void> {
-    return this.ipc.windows.setWindowResizable(params);
-  }
-
   async setWindowSize(params: WindowSizeParams): Promise<void> {
     return this.ipc.windows.setWindowSize(params);
   }
 
+  async setWindowMinimumSize(params: WindowMinimumSizeParams): Promise<void> {
+    return this.ipc.windows.setWindowMinimumSize(params);
+  }
+
   async openExternalLink(url: string): Promise<void> {
     return this.ipc.system.openExternalLink(url);
   }