@fastgpt-sdk/sandbox-adapter 0.0.19 → 0.0.21

package/README.md

@@ -10,6 +10,24 @@ A unified, high-level abstraction layer for cloud sandbox providers. It offers a
 pnpm add @fastgpt/sandbox
 ```
 
+## Next.js 集成
+
+如果在 Next.js 项目中使用，需要配置以处理 ESM 依赖。在 `next.config.js` 中添加：
+
+```javascript
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ['@fastgpt-sdk/sandbox-adapter'],
+  experimental: {
+    esmExternals: 'loose',
+  },
+};
+
+module.exports = nextConfig;
+```
+
+详细说明请参考 [Next.js 集成指南](./docs/NEXTJS_INTEGRATION.md)。
+
 ## 用途
 
 ### 1. 操作沙盒

package/dist/adapters/E2BAdapter/index.d.ts

@@ -0,0 +1,38 @@
+import { BaseSandboxAdapter } from '../BaseSandboxAdapter';
+import type { ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo, FileWriteEntry, FileWriteResult, FileDeleteResult, FileReadResult, MoveEntry, DirectoryEntry } from '@/types';
+import type { E2BConfig } from './type';
+/**
+ * E2B 沙盒适配器 - 使用官方 SDK
+ *
+ * 使用 metadata 映射上游 sandboxId 到 E2B 实际 ID
+ */
+export declare class E2BAdapter extends BaseSandboxAdapter {
+    private config;
+    readonly provider: "e2b";
+    private sandbox;
+    private _id;
+    constructor(config: E2BConfig);
+    get id(): SandboxId;
+    /**
+     * 通过 metadata 查找 E2B 沙盒实例
+     * @returns E2B Sandbox 实例，如果未找到则返回 null
+     */
+    private findSandbox;
+    private ensureSandbox;
+    ensureRunning(): Promise<void>;
+    create(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    delete(): Promise<void>;
+    getInfo(): Promise<SandboxInfo | null>;
+    execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
+    readFiles(paths: string[]): Promise<FileReadResult[]>;
+    writeFiles(files: FileWriteEntry[]): Promise<FileWriteResult[]>;
+    deleteFiles(paths: string[]): Promise<FileDeleteResult[]>;
+    moveFiles(moves: MoveEntry[]): Promise<void>;
+    createDirectories(paths: string[]): Promise<void>;
+    deleteDirectories(paths: string[]): Promise<void>;
+    listDirectory(path: string): Promise<DirectoryEntry[]>;
+    ping(): Promise<boolean>;
+}
+export type { E2BConfig } from './type';

package/dist/adapters/E2BAdapter/type.d.ts

@@ -0,0 +1,17 @@
+/**
+ * E2B 适配器配置
+ */
+export interface E2BConfig {
+    /** E2B API Key */
+    apiKey: string;
+    /** 可选的沙盒 ID，用于连接到已存在的沙盒 */
+    sandboxId: string;
+    /** 可选的模板 ID，用于创建新沙盒 */
+    template?: string;
+    /** 可选的超时时间（秒） */
+    timeout?: number;
+    /** 可选的环境变量 */
+    envs?: Record<string, string>;
+    /** 可选的元数据 */
+    metadata?: Record<string, string>;
+}

package/dist/adapters/index.d.ts

@@ -1,21 +1,26 @@
 import { type SealosDevboxConfig } from './SealosDevboxAdapter';
 import { type OpenSandboxConnectionConfig, type OpenSandboxConfigType } from './OpenSandboxAdapter';
+import { type E2BConfig } from './E2BAdapter';
 import { ISandbox } from '@/interfaces';
 export { SealosDevboxAdapter } from './SealosDevboxAdapter';
 export type { SealosDevboxConfig } from './SealosDevboxAdapter';
 export { OpenSandboxAdapter } from './OpenSandboxAdapter';
 export type { OpenSandboxConfigType, OpenSandboxConnectionConfig } from './OpenSandboxAdapter';
-export type SandboxProviderType = 'opensandbox' | 'sealosdevbox';
+export { E2BAdapter } from './E2BAdapter';
+export type { E2BConfig } from './E2BAdapter';
+export type SandboxProviderType = 'opensandbox' | 'sealosdevbox' | 'e2b';
 /** Maps each provider name to the ISandbox config type it exposes. */
 interface SandboxConfigMap {
     opensandbox: OpenSandboxConfigType;
     sealosdevbox: undefined;
+    e2b: undefined;
 }
 /** Resolves the concrete ISandbox type for a given provider. */
 /** Maps each provider name to its constructor (connection) config type. */
 interface SandboxConnectionConfig {
     opensandbox: OpenSandboxConnectionConfig;
     sealosdevbox: SealosDevboxConfig;
+    e2b: E2BConfig;
 }
 /**
  * Create a sandbox provider instance.

package/dist/index.js

@@ -825,6 +825,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
       this._status = { state: "Creating" };
       await this.api.create(this._id);
       await this.waitUntilReady();
+      await new Promise((resolve) => setTimeout(resolve, 1000));
       this._status = { state: "Running" };
     } catch (error) {
       throw new ConnectionError("Failed to create sandbox", this.config.baseUrl, error);
@@ -861,7 +862,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
   }
   async execute(command, options) {
     const cmd = this.buildCommand(command, options?.workingDirectory);
-    console.log(cmd, 2322222222222);
     try {
       const res = await this.api.exec(this._id, {
         command: cmd,
@@ -1278,6 +1278,318 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   }
 }
 
+// src/adapters/E2BAdapter/index.ts
+import { Sandbox as Sandbox2, CommandExitError, FileType } from "@e2b/code-interpreter";
+class E2BAdapter extends BaseSandboxAdapter {
+  config;
+  provider = "e2b";
+  sandbox = null;
+  _id;
+  constructor(config) {
+    super();
+    this.config = config;
+    this._id = config.sandboxId;
+    this.polyfillService = new CommandPolyfillService(this);
+  }
+  get id() {
+    return this._id;
+  }
+  async findSandbox() {
+    try {
+      const paginator = Sandbox2.list({
+        apiKey: this.config.apiKey,
+        query: {
+          metadata: { upstreamId: this._id }
+        },
+        limit: 1
+      });
+      const sandboxes = await paginator.nextItems();
+      if (sandboxes.length > 0) {
+        const sandboxInfo = sandboxes[0];
+        const sandbox = await Sandbox2.connect(sandboxInfo.sandboxId, {
+          apiKey: this.config.apiKey
+        });
+        return sandbox;
+      }
+      return null;
+    } catch (error) {
+      console.error("Failed to find sandbox by metadata:", error);
+      return Promise.reject(new Error("Failed to find sandbox by metadata"));
+    }
+  }
+  async ensureSandbox() {
+    await this.ensureRunning();
+    return this.sandbox;
+  }
+  async ensureRunning() {
+    try {
+      if (!this.sandbox) {
+        this.sandbox = await this.findSandbox();
+      }
+      if (this.sandbox) {
+        const isRunning = await this.sandbox.isRunning();
+        if (isRunning) {
+          this._status = { state: "Running" };
+          return;
+        }
+        await Sandbox2.connect(this.sandbox.sandboxId, {
+          apiKey: this.config.apiKey
+        });
+        await this.waitUntilReady();
+        this._status = { state: "Running" };
+        return;
+      }
+      await this.create();
+    } catch (error) {
+      throw new ConnectionError("Failed to ensure sandbox running", "e2b", error);
+    }
+  }
+  async create() {
+    try {
+      this._status = { state: "Creating" };
+      const options = {
+        apiKey: this.config.apiKey,
+        template: this.config.template,
+        timeout: this.config.timeout,
+        envs: this.config.envs,
+        metadata: {
+          ...this.config.metadata,
+          upstreamId: this._id
+        }
+      };
+      this.sandbox = await Sandbox2.create(options);
+      await this.waitUntilReady();
+      this._status = { state: "Running" };
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError("Failed to create E2B sandbox", "e2b", error);
+    }
+  }
+  async start() {
+    await this.ensureSandbox();
+  }
+  async stop() {
+    const sandbox = await this.ensureSandbox();
+    try {
+      this._status = { state: "Stopping" };
+      await sandbox.pause({
+        apiKey: this.config.apiKey
+      });
+      this._status = { state: "Stopped" };
+    } catch (error) {
+      throw new CommandExecutionError("Failed to pause E2B sandbox", "stop", error instanceof Error ? error : undefined);
+    }
+  }
+  async delete() {
+    const sandbox = await this.ensureSandbox();
+    try {
+      this._status = { state: "Deleting" };
+      await sandbox.kill();
+      this.sandbox = null;
+      this._status = { state: "UnExist" };
+    } catch (error) {
+      throw new CommandExecutionError("Failed to kill E2B sandbox", "delete", error instanceof Error ? error : undefined);
+    }
+  }
+  async getInfo() {
+    try {
+      const sandbox = await this.ensureSandbox();
+      const isRunning = await sandbox.isRunning();
+      return {
+        id: this._id,
+        image: { repository: this.config.template || "default" },
+        entrypoint: [],
+        status: {
+          state: isRunning ? "Running" : "Stopped"
+        },
+        createdAt: new Date
+      };
+    } catch {
+      return null;
+    }
+  }
+  async execute(command, options) {
+    try {
+      const sandbox = await this.ensureSandbox();
+      const result = await sandbox.commands.run(command, {
+        cwd: options?.workingDirectory,
+        timeoutMs: options?.timeoutMs
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode
+      };
+    } catch (error) {
+      if (error instanceof CommandExitError) {
+        return {
+          stdout: error.stdout ?? "",
+          stderr: error.stderr ?? "",
+          exitCode: error.exitCode ?? 1
+        };
+      }
+      throw new CommandExecutionError(`Command execution failed: ${error}`, command, error instanceof Error ? error : undefined);
+    }
+  }
+  async readFiles(paths) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      const results = [];
+      for (const path of paths) {
+        try {
+          const content = await sandbox.files.read(path);
+          results.push({
+            path,
+            content: Buffer.from(content),
+            error: null
+          });
+        } catch (error) {
+          results.push({
+            path,
+            content: new Uint8Array,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }
+      return results;
+    } catch (error) {
+      throw new CommandExecutionError("Failed to read files", "readFiles", error instanceof Error ? error : undefined);
+    }
+  }
+  async writeFiles(files) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      const results = [];
+      const writeData = files.map((f) => {
+        let data;
+        if (typeof f.data === "string") {
+          data = f.data;
+        } else if (f.data instanceof Uint8Array) {
+          data = f.data.buffer;
+        } else if (f.data instanceof ArrayBuffer) {
+          data = f.data;
+        } else {
+          data = "";
+        }
+        return {
+          path: f.path,
+          data
+        };
+      });
+      try {
+        await sandbox.files.write(writeData);
+        for (const file of files) {
+          let size = 0;
+          if (typeof file.data === "string") {
+            size = Buffer.byteLength(file.data);
+          } else if (file.data instanceof ArrayBuffer) {
+            size = file.data.byteLength;
+          } else if (file.data instanceof Uint8Array) {
+            size = file.data.byteLength;
+          }
+          results.push({
+            path: file.path,
+            bytesWritten: size,
+            error: null
+          });
+        }
+      } catch (error) {
+        for (const file of files) {
+          results.push({
+            path: file.path,
+            bytesWritten: 0,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }
+      return results;
+    } catch (error) {
+      throw new CommandExecutionError("Failed to write files", "writeFiles", error instanceof Error ? error : undefined);
+    }
+  }
+  async deleteFiles(paths) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      const results = [];
+      for (const path of paths) {
+        try {
+          await sandbox.files.remove(path);
+          results.push({
+            path,
+            success: true,
+            error: null
+          });
+        } catch (error) {
+          results.push({
+            path,
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }
+      return results;
+    } catch (error) {
+      throw new CommandExecutionError("Failed to delete files", "deleteFiles", error instanceof Error ? error : undefined);
+    }
+  }
+  async moveFiles(moves) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      for (const { source, destination } of moves) {
+        await sandbox.files.rename(source, destination);
+      }
+    } catch (error) {
+      throw new CommandExecutionError("Failed to move files", "moveFiles", error instanceof Error ? error : undefined);
+    }
+  }
+  async createDirectories(paths) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      for (const path of paths) {
+        await sandbox.files.makeDir(path);
+      }
+    } catch (error) {
+      throw new CommandExecutionError("Failed to create directories", "createDirectories", error instanceof Error ? error : undefined);
+    }
+  }
+  async deleteDirectories(paths) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      for (const path of paths) {
+        await sandbox.files.remove(path);
+      }
+    } catch (error) {
+      throw new CommandExecutionError("Failed to delete directories", "deleteDirectories", error instanceof Error ? error : undefined);
+    }
+  }
+  async listDirectory(path) {
+    const sandbox = await this.ensureSandbox();
+    try {
+      const entries = await sandbox.files.list(path);
+      return entries.map((entry) => {
+        const isDirectory = entry.type === FileType.DIR;
+        return {
+          name: entry.name,
+          path: entry.path,
+          isDirectory,
+          isFile: !isDirectory,
+          size: entry.size
+        };
+      });
+    } catch (error) {
+      throw new CommandExecutionError(`Failed to list directory: ${path}`, "listDirectory", error instanceof Error ? error : undefined);
+    }
+  }
+  async ping() {
+    try {
+      const sandbox = await this.ensureSandbox();
+      return await sandbox.isRunning();
+    } catch {
+      return false;
+    }
+  }
+}
+
 // src/adapters/index.ts
 function createSandbox(provider, config, createConfig) {
   switch (provider) {
@@ -1285,6 +1597,8 @@ function createSandbox(provider, config, createConfig) {
       return new OpenSandboxAdapter(config, createConfig);
     case "sealosdevbox":
       return new SealosDevboxAdapter(config);
+    case "e2b":
+      return new E2BAdapter(config);
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
@@ -1299,6 +1613,7 @@ export {
   OpenSandboxAdapter,
   FileOperationError,
   FeatureNotSupportedError,
+  E2BAdapter,
   ConnectionError,
   CommandExecutionError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastgpt-sdk/sandbox-adapter",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Unified abstraction layer for cloud sandbox providers with adapter pattern and feature polyfilling",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,6 +22,20 @@
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "prepublishOnly": "bun run build",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "lint-staged": "lint-staged",
+    "prepare": "husky",
+    "test": "vitest run --config ./vitest.config.mts",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage"
+  },
   "keywords": [
     "sandbox",
     "cloud",
@@ -33,7 +47,8 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@alibaba-group/opensandbox": "^0.1.4"
+    "@alibaba-group/opensandbox": "^0.1.4",
+    "@e2b/code-interpreter": "^2.3.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
@@ -58,17 +73,5 @@
     "*.{js,cjs,mjs,ts,tsx}": [
       "eslint --max-warnings=0"
     ]
-  },
-  "scripts": {
-    "build": "bun run build.ts",
-    "dev": "tsc -p tsconfig.build.json --watch",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier . --write",
-    "format:check": "prettier . --check",
-    "lint-staged": "lint-staged",
-    "test": "vitest run --config ./vitest.config.mts",
-    "test:watch": "vitest watch",
-    "test:coverage": "vitest run --coverage"
   }
-}
+}