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

package/packages/builtin-tool-cloud-sandbox/src/ExecutionRuntime/index.ts

@@ -1,125 +1,62 @@
+import {
+  formatEditResult,
+  formatFileContent,
+  formatFileList,
+  formatFileSearchResults,
+  formatGlobResults,
+  formatMoveResults,
+  formatRenameResult,
+  formatWriteResult,
+} from '@lobechat/prompts';
 import { type BuiltinServerRuntimeOutput } from '@lobechat/types';
 
-import { codeInterpreterService } from '@/services/codeInterpreter';
-
 import {
+  type EditLocalFileParams,
   type EditLocalFileState,
+  type ExecuteCodeParams,
   type ExecuteCodeState,
+  type ExportFileParams,
   type ExportFileState,
+  type GetCommandOutputParams,
   type GetCommandOutputState,
   type GlobFilesState,
+  type GlobLocalFilesParams,
+  type GrepContentParams,
   type GrepContentState,
+  type ISandboxService,
+  type KillCommandParams,
   type KillCommandState,
+  type ListLocalFilesParams,
   type ListLocalFilesState,
+  type MoveLocalFilesParams,
   type MoveLocalFilesState,
+  type ReadLocalFileParams,
   type ReadLocalFileState,
+  type RenameLocalFileParams,
   type RenameLocalFileState,
+  type RunCommandParams,
   type RunCommandState,
+  type SearchLocalFilesParams,
   type SearchLocalFilesState,
+  type WriteLocalFileParams,
   type WriteLocalFileState,
 } from '../types';
 
 /**
  * Cloud Sandbox Execution Runtime
  *
- * This runtime executes tools via the LobeHub Market SDK's runBuildInTool API,
- * which connects to AWS Bedrock AgentCore sandbox.
+ * This runtime executes tools via the injected ISandboxService.
+ * The service handles context (topicId, userId) internally - Runtime doesn't need to know about it.
  *
- * Session Management:
- * - Sessions are automatically created per userId + topicId combination
- * - Sessions are recreated automatically if expired
- * - The sessionExpiredAndRecreated flag indicates if recreation occurred
+ * Dependency Injection:
+ * - Client: Inject codeInterpreterService (uses tRPC client)
+ * - Server: Inject ServerSandboxService (uses MarketSDK directly)
  */
-
-interface ExecutionContext {
-  topicId: string;
-  userId: string;
-}
-
-// Types for tool parameters matching market-sdk
-interface ListLocalFilesParams {
-  directoryPath: string;
-}
-
-interface ReadLocalFileParams {
-  endLine?: number;
-  path: string;
-  startLine?: number;
-}
-
-interface WriteLocalFileParams {
-  content: string;
-  createDirectories?: boolean;
-  path: string;
-}
-
-interface EditLocalFileParams {
-  all?: boolean;
-  path: string;
-  replace: string;
-  search: string;
-}
-
-interface SearchLocalFilesParams {
-  directory: string;
-  fileType?: string;
-  keyword?: string;
-  modifiedAfter?: string;
-  modifiedBefore?: string;
-}
-
-interface MoveLocalFilesParams {
-  operations: Array<{
-    destination: string;
-    source: string;
-  }>;
-}
-
-interface RenameLocalFileParams {
-  newName: string;
-  oldPath: string;
-}
-
-interface RunCommandParams {
-  background?: boolean;
-  command: string;
-  timeout?: number;
-}
-
-interface GetCommandOutputParams {
-  commandId: string;
-}
-
-interface KillCommandParams {
-  commandId: string;
-}
-
-interface GrepContentParams {
-  directory: string;
-  filePattern?: string;
-  pattern: string;
-  recursive?: boolean;
-}
-
-interface GlobLocalFilesParams {
-  directory?: string;
-  pattern: string;
-}
-
-interface ExportFileParams {
-  path: string;
-}
-
-interface ExecuteCodeParams {
-  code: string;
-  language?: 'javascript' | 'python' | 'typescript';
-}
-
 export class CloudSandboxExecutionRuntime {
-  private context: ExecutionContext;
+  private sandboxService: ISandboxService;
 
-  constructor(context: ExecutionContext) {
-    this.context = context;
+  constructor(sandboxService: ISandboxService) {
+    this.sandboxService = sandboxService;
   }
 
   // ==================== File Operations ====================
@@ -128,12 +65,19 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('listLocalFiles', args);
 
-      const state: ListLocalFilesState = {
-        files: result.result?.files || [],
-      };
+      const files = result.result?.files || [];
+      const state: ListLocalFilesState = { files };
+
+      const content = formatFileList(
+        files.map((f: { isDirectory: boolean; name: string }) => ({
+          isDirectory: f.isDirectory,
+          name: f.name,
+        })),
+        args.directoryPath,
+      );
 
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -154,8 +98,19 @@ export class CloudSandboxExecutionRuntime {
         totalLines: result.result?.totalLines,
       };
 
+      const lineRange: [number, number] | undefined =
+        args.startLine !== undefined && args.endLine !== undefined
+          ? [args.startLine, args.endLine]
+          : undefined;
+
+      const content = formatFileContent({
+        content: result.result?.content || '',
+        lineRange,
+        path: args.path,
+      });
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -174,11 +129,13 @@ export class CloudSandboxExecutionRuntime {
         success: result.success,
       };
 
+      const content = formatWriteResult({
+        path: args.path,
+        success: true,
+      });
+
       return {
-        content: JSON.stringify({
-          message: `Successfully wrote to ${args.path}`,
-          success: true,
-        }),
+        content,
         state,
         success: true,
       };
@@ -199,13 +156,15 @@ export class CloudSandboxExecutionRuntime {
         replacements: result.result?.replacements || 0,
       };
 
-      const statsText =
-        state.linesAdded || state.linesDeleted
-          ? ` (+${state.linesAdded || 0} -${state.linesDeleted || 0})`
-          : '';
+      const content = formatEditResult({
+        filePath: args.path,
+        linesAdded: state.linesAdded,
+        linesDeleted: state.linesDeleted,
+        replacements: state.replacements,
+      });
 
       return {
-        content: `Successfully replaced ${state.replacements} occurrence(s) in ${args.path}${statsText}`,
+        content,
         state,
         success: true,
       };
@@ -218,13 +177,18 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('searchLocalFiles', args);
 
+      const results = result.result?.results || [];
       const state: SearchLocalFilesState = {
-        results: result.result?.results || [],
+        results,
         totalCount: result.result?.totalCount || 0,
       };
 
+      const content = formatFileSearchResults(
+        results.map((r: { path: string }) => ({ path: r.path })),
+      );
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -237,17 +201,17 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('moveLocalFiles', args);
 
+      const results = result.result?.results || [];
       const state: MoveLocalFilesState = {
-        results: result.result?.results || [],
+        results,
         successCount: result.result?.successCount || 0,
         totalCount: args.operations.length,
       };
 
+      const content = formatMoveResults(results);
+
       return {
-        content: JSON.stringify({
-          message: `Moved ${state.successCount}/${state.totalCount} items`,
-          results: state.results,
-        }),
+        content,
         state,
         success: true,
       };
@@ -267,11 +231,15 @@ export class CloudSandboxExecutionRuntime {
         success: result.success,
       };
 
+      const content = formatRenameResult({
+        error: result.result?.error,
+        newName: args.newName,
+        oldPath: args.oldPath,
+        success: result.success,
+      });
+
       return {
-        content: JSON.stringify({
-          message: `Successfully renamed ${args.oldPath} to ${args.newName}`,
-          success: true,
-        }),
+        content,
         state,
         success: result.success,
       };
@@ -405,14 +373,22 @@ export class CloudSandboxExecutionRuntime {
     try {
       const result = await this.callTool('globLocalFiles', args);
 
+      const files = result.result?.files || [];
+      const totalCount = result.result?.totalCount || 0;
+
       const state: GlobFilesState = {
-        files: result.result?.files || [],
+        files,
         pattern: args.pattern,
-        totalCount: result.result?.totalCount || 0,
+        totalCount,
       };
 
+      const content = formatGlobResults({
+        files,
+        totalFiles: totalCount,
+      });
+
       return {
-        content: JSON.stringify(result.result),
+        content,
         state,
         success: true,
       };
@@ -425,7 +401,7 @@ export class CloudSandboxExecutionRuntime {
 
   /**
    * Export a file from the sandbox to cloud storage
-   * Uses a single tRPC call that handles:
+   * Uses a single call that handles:
    * 1. Generate pre-signed upload URL
    * 2. Call sandbox to upload file
    * 3. Create persistent file record
@@ -437,11 +413,7 @@ export class CloudSandboxExecutionRuntime {
       const filename = args.path.split('/').pop() || 'exported_file';
 
       // Single call that handles everything: upload URL generation, sandbox upload, and file record creation
-      const result = await codeInterpreterService.exportAndUploadFile(
-        args.path,
-        filename,
-        this.context.topicId,
-      );
+      const result = await this.sandboxService.exportAndUploadFile(args.path, filename);
 
       const state: ExportFileState = {
         downloadUrl: result.success && result.url ? result.url : '',
@@ -478,17 +450,16 @@ export class CloudSandboxExecutionRuntime {
   // ==================== Helper Methods ====================
 
   /**
-   * Call a tool via the market SDK through tRPC
-   * Routes through: ExecutionRuntime -> codeInterpreterService -> tRPC -> codeInterpreterRouter -> MarketSDK
+   * Call a tool via the injected sandbox service
    */
   private async callTool(
     toolName: string,
     params: Record<string, any>,
   ): Promise<{ result: any; sessionExpiredAndRecreated?: boolean; success: boolean }> {
-    const result = await codeInterpreterService.callTool(toolName, params, this.context);
+    const result = await this.sandboxService.callTool(toolName, params);
 
     if (!result.success) {
-      throw new Error((result as any).error?.message || `Cloud Sandbox tool ${toolName} failed`);
+      throw new Error(result.error?.message || `Cloud Sandbox tool ${toolName} failed`);
     }
 
     return result;

package/packages/builtin-tool-cloud-sandbox/src/executor/index.ts

@@ -0,0 +1,254 @@
+import { BaseExecutor, type BuiltinToolContext, type BuiltinToolResult } from '@lobechat/types';
+
+import { cloudSandboxService } from '@/services/cloudSandbox';
+import { useUserStore } from '@/store/user';
+import { userProfileSelectors } from '@/store/user/slices/auth/selectors';
+
+import { CloudSandboxExecutionRuntime } from '../ExecutionRuntime';
+import { CloudSandboxIdentifier } from '../manifest';
+import {
+  CloudSandboxApiName,
+  type EditLocalFileParams,
+  type ExecuteCodeParams,
+  type ExportFileParams,
+  type GetCommandOutputParams,
+  type GlobLocalFilesParams,
+  type GrepContentParams,
+  type ISandboxService,
+  type KillCommandParams,
+  type ListLocalFilesParams,
+  type MoveLocalFilesParams,
+  type ReadLocalFileParams,
+  type RenameLocalFileParams,
+  type RunCommandParams,
+  type SandboxCallToolResult,
+  type SandboxExportFileResult,
+  type SearchLocalFilesParams,
+  type WriteLocalFileParams,
+} from '../types';
+
+/**
+ * Client-side Sandbox Service
+ * Wraps codeInterpreterService with bound context (topicId, userId)
+ */
+class ClientSandboxService implements ISandboxService {
+  private topicId: string;
+  private userId: string;
+
+  constructor(topicId: string) {
+    this.topicId = topicId;
+    // Get userId from user store - client-side auth
+    const userId = userProfileSelectors.userId(useUserStore.getState());
+    if (!userId) {
+      throw new Error('userId must be provided');
+    }
+    this.userId = userId;
+  }
+
+  async callTool(toolName: string, params: Record<string, any>): Promise<SandboxCallToolResult> {
+    return cloudSandboxService.callTool(toolName, params, {
+      topicId: this.topicId,
+      userId: this.userId,
+    });
+  }
+
+  async exportAndUploadFile(path: string, filename: string): Promise<SandboxExportFileResult> {
+    return cloudSandboxService.exportAndUploadFile(path, filename, this.topicId);
+  }
+}
+
+/**
+ * Cloud Sandbox Client Executor
+ *
+ * This executor handles Cloud Sandbox tool calls on the client side.
+ * It creates a CloudSandboxExecutionRuntime with a ClientSandboxService
+ * that has topicId bound at construction time.
+ */
+class CloudSandboxExecutor extends BaseExecutor<typeof CloudSandboxApiName> {
+  readonly identifier = CloudSandboxIdentifier;
+  protected readonly apiEnum = CloudSandboxApiName;
+
+  /**
+   * Get or create a runtime for the given context
+   */
+  private getRuntime(ctx: BuiltinToolContext): CloudSandboxExecutionRuntime {
+    const topicId = ctx.topicId;
+
+    if (!topicId) {
+      throw new Error('Can not init runtime with empty topicId');
+    }
+
+    const service = new ClientSandboxService(topicId);
+    return new CloudSandboxExecutionRuntime(service);
+  }
+
+  // ==================== File Operations ====================
+
+  listLocalFiles = async (
+    params: ListLocalFilesParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.listLocalFiles(params);
+    return this.toBuiltinResult(result);
+  };
+
+  readLocalFile = async (
+    params: ReadLocalFileParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.readLocalFile(params);
+    return this.toBuiltinResult(result);
+  };
+
+  writeLocalFile = async (
+    params: WriteLocalFileParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.writeLocalFile(params);
+    return this.toBuiltinResult(result);
+  };
+
+  editLocalFile = async (
+    params: EditLocalFileParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.editLocalFile(params);
+    return this.toBuiltinResult(result);
+  };
+
+  searchLocalFiles = async (
+    params: SearchLocalFilesParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.searchLocalFiles(params);
+    return this.toBuiltinResult(result);
+  };
+
+  moveLocalFiles = async (
+    params: MoveLocalFilesParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.moveLocalFiles(params);
+    return this.toBuiltinResult(result);
+  };
+
+  renameLocalFile = async (
+    params: RenameLocalFileParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.renameLocalFile(params);
+    return this.toBuiltinResult(result);
+  };
+
+  // ==================== Code Execution ====================
+
+  executeCode = async (
+    params: ExecuteCodeParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.executeCode(params);
+    return this.toBuiltinResult(result);
+  };
+
+  // ==================== Shell Commands ====================
+
+  runCommand = async (
+    params: RunCommandParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.runCommand(params);
+    return this.toBuiltinResult(result);
+  };
+
+  getCommandOutput = async (
+    params: GetCommandOutputParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.getCommandOutput(params);
+    return this.toBuiltinResult(result);
+  };
+
+  killCommand = async (
+    params: KillCommandParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.killCommand(params);
+    return this.toBuiltinResult(result);
+  };
+
+  // ==================== Search & Find ====================
+
+  grepContent = async (
+    params: GrepContentParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.grepContent(params);
+    return this.toBuiltinResult(result);
+  };
+
+  globLocalFiles = async (
+    params: GlobLocalFilesParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.globLocalFiles(params);
+    return this.toBuiltinResult(result);
+  };
+
+  // ==================== Export Operations ====================
+
+  exportFile = async (
+    params: ExportFileParams,
+    ctx: BuiltinToolContext,
+  ): Promise<BuiltinToolResult> => {
+    const runtime = this.getRuntime(ctx);
+    const result = await runtime.exportFile(params);
+    return this.toBuiltinResult(result);
+  };
+
+  // ==================== Helper Methods ====================
+
+  /**
+   * Convert BuiltinServerRuntimeOutput to BuiltinToolResult
+   */
+  private toBuiltinResult(output: {
+    content: string;
+    error?: any;
+    state?: any;
+    success: boolean;
+  }): BuiltinToolResult {
+    if (!output.success) {
+      return {
+        content: output.content,
+        error: {
+          body: output.error,
+          message: output.content || 'Unknown error',
+          type: 'PluginServerError',
+        },
+        state: output.state,
+        success: false,
+      };
+    }
+
+    return {
+      content: output.content,
+      state: output.state,
+      success: true,
+    };
+  }
+}
+
+// Export the executor instance for registration
+export const cloudSandboxExecutor = new CloudSandboxExecutor();

package/packages/builtin-tool-cloud-sandbox/src/index.ts

@@ -1,3 +1,4 @@
+export * from './ExecutionRuntime';
 export * from './manifest';
 export * from './systemRole';
 export * from './types';

package/packages/builtin-tool-cloud-sandbox/src/types/api.ts

@@ -0,0 +1,22 @@
+/**
+ * API names for Cloud Sandbox tool
+ */
+export const CloudSandboxApiName = {
+  editLocalFile: 'editLocalFile',
+  executeCode: 'executeCode',
+  exportFile: 'exportFile',
+  getCommandOutput: 'getCommandOutput',
+  globLocalFiles: 'globLocalFiles',
+  grepContent: 'grepContent',
+  killCommand: 'killCommand',
+  listLocalFiles: 'listLocalFiles',
+  moveLocalFiles: 'moveLocalFiles',
+  readLocalFile: 'readLocalFile',
+  renameLocalFile: 'renameLocalFile',
+  runCommand: 'runCommand',
+  searchLocalFiles: 'searchLocalFiles',
+  writeLocalFile: 'writeLocalFile',
+} as const;
+
+export type CloudSandboxApiNameType =
+  (typeof CloudSandboxApiName)[keyof typeof CloudSandboxApiName];

package/packages/builtin-tool-cloud-sandbox/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './api';
+export * from './params';
+export * from './service';
+export * from './state';