@fastgpt-sdk/sandbox-adapter 0.0.31 → 0.0.33

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -9,11 +9,24 @@ import type { ContentReplaceEntry, DirectoryEntry, ExecuteOptions, ExecuteResult
  * Subclasses can override the polyfill service in their constructor.
  */
 export declare abstract class BaseSandboxAdapter implements ISandbox {
-    abstract readonly id: SandboxId;
+    abstract readonly id?: SandboxId;
     abstract readonly provider: string;
     protected _status: SandboxStatus;
     protected polyfillService?: CommandPolyfillService;
     constructor();
+    /**
+     * The root path of the sandbox filesystem.
+     * Subclasses should override this to return the provider-specific root path.
+     */
+    get rootPath(): string;
+    /**
+     * Normalize a path relative to rootPath.
+     * - '.' or './' → rootPath
+     * - './foo' → rootPath/foo
+     * - 'foo' → rootPath/foo
+     * - '/absolute' → '/absolute' (pass through)
+     */
+    protected normalizePath(path?: string): string;
     get status(): SandboxStatus;
     abstract ensureRunning(): Promise<void>;
     abstract create(): Promise<void>;
@@ -22,6 +35,7 @@ export declare abstract class BaseSandboxAdapter implements ISandbox {
     abstract delete(): Promise<void>;
     abstract getInfo(): Promise<SandboxInfo | null>;
     waitUntilReady(timeoutMs?: number): Promise<void>;
+    waitUntilDeleted(timeoutMs?: number): Promise<void>;
     renewExpiration(_additionalSeconds: number): Promise<void>;
     abstract execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
     executeStream(command: string, handlers: StreamHandlers, options?: ExecuteOptions): Promise<void>;

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

@@ -9,6 +9,7 @@ import type { E2BConfig } from './type';
 export declare class E2BAdapter extends BaseSandboxAdapter {
     private config;
     readonly provider: "e2b";
+    get rootPath(): string;
     private sandbox;
     private _id;
     constructor(config: E2BConfig);

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

@@ -4,7 +4,7 @@
 export interface E2BConfig {
     /** E2B API Key */
     apiKey: string;
-    /** 可选的沙盒 ID，用于连接到已存在的沙盒 */
+    /** 的沙盒 ID，用于连接到已存在的沙盒 */
     sandboxId: string;
     /** 可选的模板 ID，用于创建新沙盒 */
     template?: string;

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

@@ -12,8 +12,9 @@ export type SandboxRuntimeType = 'docker' | 'kubernetes';
  * Connection configuration options for OpenSandboxAdapter.
  */
 export interface OpenSandboxConnectionConfig {
+    sessionId: string;
     /** Base URL for the OpenSandbox API */
-    baseUrl?: string;
+    baseUrl: string;
     /** API key for authentication */
     apiKey?: string;
     /** SDK request timeout in seconds */
@@ -50,14 +51,16 @@ export interface OpenSandboxConnectionConfig {
  */
 export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private connectionConfig;
-    private createConfig?;
+    private createConfig;
     readonly provider: "opensandbox";
     readonly runtime: SandboxRuntimeType;
     private _sandbox?;
     private _connection;
-    private _id;
-    constructor(connectionConfig?: OpenSandboxConnectionConfig, createConfig?: OpenSandboxConfigType | undefined);
-    get id(): SandboxId;
+    private _id?;
+    constructor(connectionConfig: OpenSandboxConnectionConfig, createConfig: OpenSandboxConfigType);
+    get rootPath(): string;
+    get id(): SandboxId | undefined;
+    private set sandbox(value);
     private get sandbox();
     private createConnectionConfig;
     private static readonly STATE_MAP;
@@ -67,9 +70,11 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private convertResourceLimits;
     private parseResourceLimits;
     private extractExitCode;
+    private getSandboxBySessionId;
     ensureRunning(): Promise<void>;
     create(): Promise<void>;
     connect(sandboxId: string): Promise<void>;
+    private resume;
     start(): Promise<void>;
     stop(): Promise<void>;
     delete(): Promise<void>;
@@ -85,11 +90,6 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
      * @returns Endpoint with host, port, protocol and url fields
      */
     getEndpoint(port: number): Promise<Endpoint>;
-    /**
-     * Convert SDK Endpoint (no-scheme string) to our Endpoint type.
-     * SDK format: "localhost:44772" or "domain/route/.../44772"
-     */
-    private convertSdkEndpoint;
     getInfo(): Promise<SandboxInfo | null>;
     renewExpiration(additionalSeconds: number): Promise<void>;
     execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;

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

@@ -13,12 +13,12 @@ export interface SealosDevboxConfig {
 export declare class SealosDevboxAdapter extends BaseSandboxAdapter {
     private config;
     readonly provider: "sealosdevbox";
+    get rootPath(): string;
     private api;
     private _id;
     constructor(config: SealosDevboxConfig);
     get id(): SandboxId;
     private StatusAdapt;
-    private waitUntilDeleted;
     getInfo(): Promise<SandboxInfo | null>;
     ensureRunning(): Promise<void>;
     create(): Promise<void>;

package/dist/index.cjs

@@ -47506,6 +47506,19 @@ class BaseSandboxAdapter {
   _status = { state: "Creating" };
   polyfillService;
   constructor() {}
+  get rootPath() {
+    return "/";
+  }
+  normalizePath(path = "") {
+    if (path === "." || path === "./")
+      return this.rootPath;
+    const root = this.rootPath.replace(/\/+$/, "");
+    if (path.startsWith("./"))
+      return `${root}/${path.slice(2)}`;
+    if (!path.startsWith("/"))
+      return `${root}/${path}`;
+    return path;
+  }
   get status() {
     return this._status;
   }
@@ -47519,7 +47532,19 @@ class BaseSandboxAdapter {
       }
       await this.sleep(checkInterval);
     }
-    throw new SandboxReadyTimeoutError(this.id, timeoutMs);
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
+  }
+  async waitUntilDeleted(timeoutMs = 120000) {
+    const startTime = Date.now();
+    const checkInterval = 1000;
+    while (Date.now() - startTime < timeoutMs) {
+      const data = await this.getInfo().catch(() => true);
+      if (!data) {
+        return;
+      }
+      await this.sleep(checkInterval);
+    }
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
   }
   async renewExpiration(_additionalSeconds) {
     throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
@@ -47545,7 +47570,7 @@ class BaseSandboxAdapter {
   async readFiles(paths, options) {
     const polyfillService = this.requirePolyfillService("readFiles", "File read not supported by this provider");
     const results = [];
-    for (const path of paths) {
+    for (const path of paths.map((p) => this.normalizePath(p))) {
       try {
         let content;
         if (options?.range) {
@@ -47573,7 +47598,7 @@ class BaseSandboxAdapter {
   async writeFiles(entries) {
     const polyfillService = this.requirePolyfillService("writeFiles", "File write not supported by this provider");
     const results = [];
-    for (const entry of entries) {
+    for (const entry of entries.map((e) => ({ ...e, path: this.normalizePath(e.path) }))) {
       try {
         let bytesWritten;
         if (typeof entry.data === "string") {
@@ -47617,7 +47642,7 @@ class BaseSandboxAdapter {
   }
   async deleteFiles(paths) {
     const polyfillService = this.requirePolyfillService("deleteFiles", "File delete not supported by this provider");
-    const polyfillResults = await polyfillService.deleteFiles(paths);
+    const polyfillResults = await polyfillService.deleteFiles(paths.map((p) => this.normalizePath(p)));
     return polyfillResults.map((r) => ({
       path: r.path,
       success: r.success,
@@ -47626,7 +47651,10 @@ class BaseSandboxAdapter {
   }
   async moveFiles(entries) {
     const polyfillService = this.requirePolyfillService("moveFiles", "File move not supported by this provider");
-    await polyfillService.moveFiles(entries.map((e) => ({ source: e.source, destination: e.destination })));
+    await polyfillService.moveFiles(entries.map((e) => ({
+      source: this.normalizePath(e.source),
+      destination: this.normalizePath(e.destination)
+    })));
   }
   async replaceContent(entries) {
     const polyfillService = this.requirePolyfillService("replaceContent", "Content replace not supported by this provider");
@@ -47634,15 +47662,15 @@ class BaseSandboxAdapter {
   }
   async createDirectories(paths, options) {
     const polyfillService = this.requirePolyfillService("createDirectories", "Directory creation not supported by this provider");
-    await polyfillService.createDirectories(paths, options);
+    await polyfillService.createDirectories(paths.map((p) => this.normalizePath(p)), options);
   }
   async deleteDirectories(paths, options) {
     const polyfillService = this.requirePolyfillService("deleteDirectories", "Directory deletion not supported by this provider");
-    await polyfillService.deleteDirectories(paths, options);
+    await polyfillService.deleteDirectories(paths.map((p) => this.normalizePath(p)), options);
   }
   async listDirectory(path) {
     const polyfillService = this.requirePolyfillService("listDirectory", "Directory listing not supported by this provider");
-    return polyfillService.listDirectory(path);
+    return polyfillService.listDirectory(this.normalizePath(path));
   }
   async* readFileStream(path) {
     this.requirePolyfillService("readFileStream", "File stream read not supported by this provider");
@@ -47694,7 +47722,7 @@ class BaseSandboxAdapter {
   }
   async getFileInfo(paths) {
     const polyfillService = this.requirePolyfillService("getFileInfo", "File info not supported by this provider");
-    return polyfillService.getFileInfo(paths);
+    return polyfillService.getFileInfo(paths.map((p) => this.normalizePath(p)));
   }
   async setPermissions(entries) {
     const polyfillService = this.requirePolyfillService("setPermissions", "Permission setting not supported by this provider");
@@ -47702,7 +47730,7 @@ class BaseSandboxAdapter {
   }
   async search(pattern, path) {
     const polyfillService = this.requirePolyfillService("search", "File search not supported by this provider");
-    return polyfillService.search(pattern, path);
+    return polyfillService.search(pattern, path !== undefined ? this.normalizePath(path) : path);
   }
   async ping() {
     const polyfillService = this.requirePolyfillService("ping", "Health check not supported by this provider");
@@ -47825,6 +47853,9 @@ class DevboxApi {
 class SealosDevboxAdapter extends BaseSandboxAdapter {
   config;
   provider = "sealosdevbox";
+  get rootPath() {
+    return "/home/devbox/workspace";
+  }
   api;
   _id;
   constructor(config) {
@@ -47854,18 +47885,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
         return "Error";
     }
   }
-  async waitUntilDeleted() {
-    const startTime = Date.now();
-    const checkInterval = 1000;
-    while (Date.now() - startTime < 120000) {
-      const data = await this.getInfo().catch(() => true);
-      if (!data) {
-        return;
-      }
-      await this.sleep(checkInterval);
-    }
-    throw new TimeoutError("Sandbox not deleted", 120000, "waitUntilDeleted");
-  }
   async getInfo() {
     try {
       const res = await this.api.info(this._id);
@@ -47956,7 +47975,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
     }
   }
   async execute(command, options) {
-    const cmd = this.buildCommand(command, options?.workingDirectory);
+    const cmd = this.buildCommand(command, this.normalizePath(options?.workingDirectory));
     try {
       const res = await this.api.exec(this._id, {
         command: cmd,
@@ -47995,8 +48014,8 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   runtime;
   _sandbox;
   _connection;
-  _id = "";
-  constructor(connectionConfig = {}, createConfig) {
+  _id;
+  constructor(connectionConfig, createConfig) {
     super();
     this.connectionConfig = connectionConfig;
     this.createConfig = createConfig;
@@ -48004,9 +48023,17 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     this._connection = this.createConnectionConfig();
     this.polyfillService = new CommandPolyfillService(this);
   }
+  get rootPath() {
+    const mountPath = this.createConfig.volumes?.[0]?.mountPath;
+    return mountPath ? mountPath.replace(/\/+$/, "") : "/home/sandbox";
+  }
   get id() {
     return this._id;
   }
+  set sandbox(sandbox) {
+    this._sandbox = sandbox;
+    this._id = sandbox?.id;
+  }
   get sandbox() {
     if (!this._sandbox) {
       throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
@@ -48015,9 +48042,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   }
   createConnectionConfig() {
     const { baseUrl, apiKey, requestTimeoutSeconds, debug, useServerProxy } = this.connectionConfig;
-    if (!baseUrl) {
-      return new import_opensandbox.ConnectionConfig({ apiKey, requestTimeoutSeconds, debug, useServerProxy });
-    }
     return new import_opensandbox.ConnectionConfig({
       domain: baseUrl,
       apiKey,
@@ -48128,32 +48152,74 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return 0;
   }
+  async getSandboxBySessionId() {
+    const manager = import_opensandbox.SandboxManager.create({ connectionConfig: this._connection });
+    const result = await manager.listSandboxInfos({
+      metadata: { sessionId: this.connectionConfig.sessionId }
+    });
+    const val = result.items[0];
+    if (val) {
+      const status = this.mapStatus(val.status);
+      return {
+        id: val.id,
+        status
+      };
+    }
+  }
   async ensureRunning() {
-    return this.create();
+    const sandbox = await this.getSandboxBySessionId();
+    if (sandbox) {
+      switch (sandbox.status.state) {
+        case "UnExist":
+          await this.create();
+          break;
+        case "Running":
+          await this.connect(sandbox.id);
+          break;
+        case "Creating":
+        case "Starting":
+          await this.waitUntilReady();
+          break;
+        case "Stopping":
+        case "Stopped":
+          await this.resume(sandbox.id);
+          break;
+        case "Deleting":
+          await this.waitUntilDeleted();
+          await this.create();
+          break;
+        case "Error":
+          throw new ConnectionError(`Sandbox error: ${sandbox.status.message}`);
+        default:
+          throw new ConnectionError(`Sandbox state ${sandbox.status.state} not supported`);
+      }
+    } else {
+      await this.create();
+    }
   }
   async create() {
-    if (!this.createConfig) {
-      throw new Error("createConfig is required to create a sandbox. Pass it as the third argument to createSandbox().");
-    }
     const cfg = this.createConfig;
     try {
       this._status = { state: "Creating" };
       const image = this.convertImageSpec(cfg.image);
       const resource = this.convertResourceLimits(cfg.resourceLimits);
-      this._sandbox = await import_opensandbox.Sandbox.create({
+      this.sandbox = await import_opensandbox.Sandbox.create({
         connectionConfig: this._connection,
         image,
         entrypoint: cfg.entrypoint,
         timeoutSeconds: cfg.timeoutSeconds ?? null,
         resource,
         env: cfg.env,
-        metadata: cfg.metadata,
+        metadata: {
+          ...cfg.metadata,
+          sessionId: this.connectionConfig.sessionId
+        },
         volumes: cfg.volumes,
         skipHealthCheck: cfg.skipHealthCheck,
         readyTimeoutSeconds: cfg.readyTimeoutSeconds,
         healthCheckPollingInterval: cfg.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
@@ -48163,31 +48229,51 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async connect(sandboxId) {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await import_opensandbox.Sandbox.connect({
+      this.sandbox = await import_opensandbox.Sandbox.connect({
         sandboxId,
         connectionConfig: this._connection,
         skipHealthCheck: this.createConfig?.skipHealthCheck,
         readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
         healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
       throw new ConnectionError(`Failed to connect to sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
     }
   }
+  async resume(sandboxId) {
+    try {
+      this._status = { state: "Starting" };
+      this.sandbox = await import_opensandbox.Sandbox.resume({
+        sandboxId,
+        connectionConfig: this._connection,
+        skipHealthCheck: this.createConfig?.skipHealthCheck,
+        readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
+        healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
+      });
+      this._status = { state: "Running" };
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError(`Failed to resume sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
+    }
+  }
   async start() {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await this.sandbox.resume();
-      this._id = this.sandbox.id;
+      this.sandbox = await this.sandbox.resume();
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+      const code = error instanceof import_opensandbox.SandboxException ? error.error.code : undefined;
+      switch (code) {
+        case "DOCKER::SANDBOX_NOT_PAUSED":
+          return;
+        case "SANDBOX::API_NOT_SUPPORTED":
+          throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+        default:
+          throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
       }
-      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
     }
   }
   async stop() {
@@ -48196,6 +48282,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       await this.sandbox.pause();
       this._status = { state: "Stopped" };
     } catch (error) {
+      const message = error instanceof import_opensandbox.SandboxException ? error.error.message : undefined;
+      if (message?.includes("already paused")) {
+        return;
+      }
       if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
         throw new FeatureNotSupportedError("Stop/pause not supported by this runtime", "stop", this.provider);
       }
@@ -48206,43 +48296,38 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     try {
       this._status = { state: "Deleting" };
       await this.sandbox.kill();
-      this._sandbox = undefined;
-      this._id = "";
+      this.sandbox = undefined;
       this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
   async close() {
-    if (this._sandbox) {
-      await this._sandbox.close();
-    }
+    await this.sandbox.close();
   }
   async getEndpoint(port) {
     const sdkEndpoint = await this.sandbox.getEndpoint(port);
-    return this.convertSdkEndpoint(sdkEndpoint, port);
-  }
-  convertSdkEndpoint(sdkEndpoint, requestedPort) {
     const raw = sdkEndpoint.endpoint;
     const colonIdx = raw.lastIndexOf(":");
     const hasPathBeforeColon = colonIdx !== -1 && raw.slice(0, colonIdx).includes("/");
     if (colonIdx !== -1 && !hasPathBeforeColon) {
       const host = raw.slice(0, colonIdx);
       const parsedPort = parseInt(raw.slice(colonIdx + 1), 10);
-      const port = isNaN(parsedPort) ? requestedPort : parsedPort;
+      const portNumber = isNaN(parsedPort) ? port : parsedPort;
       const protocol = port === 443 ? "https" : "http";
-      return { host, port, protocol, url: `${protocol}://${raw}` };
+      return { host, port: portNumber, protocol, url: `${protocol}://${raw}` };
     }
     return {
       host: raw,
-      port: requestedPort,
+      port,
       protocol: "https",
       url: `https://${raw}`
     };
   }
   async getInfo() {
-    if (!this._sandbox)
+    if (!this._sandbox) {
       return null;
+    }
     try {
       const info = await this.sandbox.getInfo();
       return {
@@ -48269,7 +48354,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async execute(command, options) {
     try {
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: options?.background
       });
       const stdout = execution.logs.stdout.map((msg) => msg.text).join(`
@@ -48306,7 +48391,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
         } : {}
       };
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: options?.background
       }, sdkHandlers);
       if (handlers.onComplete) {
@@ -48328,7 +48413,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async executeBackground(command, options) {
     try {
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: true
       });
       if (!execution.id) {
@@ -48376,6 +48461,9 @@ var import_code_interpreter = __toESM(require_dist4());
 class E2BAdapter extends BaseSandboxAdapter {
   config;
   provider = "e2b";
+  get rootPath() {
+    return "/home/user";
+  }
   sandbox = null;
   _id;
   constructor(config) {
@@ -48505,7 +48593,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     try {
       const sandbox = await this.ensureSandbox();
       const result = await sandbox.commands.run(command, {
-        cwd: options?.workingDirectory,
+        cwd: this.normalizePath(options?.workingDirectory),
         timeoutMs: options?.timeoutMs
       });
       return {
@@ -48528,7 +48616,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       const results = [];
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         try {
           const content = await sandbox.files.read(path);
           results.push({
@@ -48565,7 +48653,7 @@ class E2BAdapter extends BaseSandboxAdapter {
           data = "";
         }
         return {
-          path: f.path,
+          path: this.normalizePath(f.path),
           data
         };
       });
@@ -48604,7 +48692,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       const results = [];
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         try {
           await sandbox.files.remove(path);
           results.push({
@@ -48629,7 +48717,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       for (const { source, destination } of moves) {
-        await sandbox.files.rename(source, destination);
+        await sandbox.files.rename(this.normalizePath(source), this.normalizePath(destination));
       }
     } catch (error) {
       throw new CommandExecutionError("Failed to move files", "moveFiles", error instanceof Error ? error : undefined);
@@ -48638,7 +48726,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async createDirectories(paths) {
     const sandbox = await this.ensureSandbox();
     try {
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         await sandbox.files.makeDir(path);
       }
     } catch (error) {
@@ -48648,7 +48736,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async deleteDirectories(paths) {
     const sandbox = await this.ensureSandbox();
     try {
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         await sandbox.files.remove(path);
       }
     } catch (error) {
@@ -48658,7 +48746,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async listDirectory(path) {
     const sandbox = await this.ensureSandbox();
     try {
-      const entries = await sandbox.files.list(path);
+      const entries = await sandbox.files.list(this.normalizePath(path));
       return entries.map((entry) => {
         const isDirectory = entry.type === import_code_interpreter.FileType.DIR;
         return {

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './adapters';
 export * from './errors';
 export * from './interfaces';
 export * from './types';
+export type { Volume as SandboxVolume } from '../opensandbox';

package/dist/index.js

@@ -47490,6 +47490,19 @@ class BaseSandboxAdapter {
   _status = { state: "Creating" };
   polyfillService;
   constructor() {}
+  get rootPath() {
+    return "/";
+  }
+  normalizePath(path = "") {
+    if (path === "." || path === "./")
+      return this.rootPath;
+    const root = this.rootPath.replace(/\/+$/, "");
+    if (path.startsWith("./"))
+      return `${root}/${path.slice(2)}`;
+    if (!path.startsWith("/"))
+      return `${root}/${path}`;
+    return path;
+  }
   get status() {
     return this._status;
   }
@@ -47503,7 +47516,19 @@ class BaseSandboxAdapter {
       }
       await this.sleep(checkInterval);
     }
-    throw new SandboxReadyTimeoutError(this.id, timeoutMs);
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
+  }
+  async waitUntilDeleted(timeoutMs = 120000) {
+    const startTime = Date.now();
+    const checkInterval = 1000;
+    while (Date.now() - startTime < timeoutMs) {
+      const data = await this.getInfo().catch(() => true);
+      if (!data) {
+        return;
+      }
+      await this.sleep(checkInterval);
+    }
+    throw new SandboxReadyTimeoutError(this.id ?? "Unknown", timeoutMs);
   }
   async renewExpiration(_additionalSeconds) {
     throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
@@ -47529,7 +47554,7 @@ class BaseSandboxAdapter {
   async readFiles(paths, options) {
     const polyfillService = this.requirePolyfillService("readFiles", "File read not supported by this provider");
     const results = [];
-    for (const path of paths) {
+    for (const path of paths.map((p) => this.normalizePath(p))) {
       try {
         let content;
         if (options?.range) {
@@ -47557,7 +47582,7 @@ class BaseSandboxAdapter {
   async writeFiles(entries) {
     const polyfillService = this.requirePolyfillService("writeFiles", "File write not supported by this provider");
     const results = [];
-    for (const entry of entries) {
+    for (const entry of entries.map((e) => ({ ...e, path: this.normalizePath(e.path) }))) {
       try {
         let bytesWritten;
         if (typeof entry.data === "string") {
@@ -47601,7 +47626,7 @@ class BaseSandboxAdapter {
   }
   async deleteFiles(paths) {
     const polyfillService = this.requirePolyfillService("deleteFiles", "File delete not supported by this provider");
-    const polyfillResults = await polyfillService.deleteFiles(paths);
+    const polyfillResults = await polyfillService.deleteFiles(paths.map((p) => this.normalizePath(p)));
     return polyfillResults.map((r) => ({
       path: r.path,
       success: r.success,
@@ -47610,7 +47635,10 @@ class BaseSandboxAdapter {
   }
   async moveFiles(entries) {
     const polyfillService = this.requirePolyfillService("moveFiles", "File move not supported by this provider");
-    await polyfillService.moveFiles(entries.map((e) => ({ source: e.source, destination: e.destination })));
+    await polyfillService.moveFiles(entries.map((e) => ({
+      source: this.normalizePath(e.source),
+      destination: this.normalizePath(e.destination)
+    })));
   }
   async replaceContent(entries) {
     const polyfillService = this.requirePolyfillService("replaceContent", "Content replace not supported by this provider");
@@ -47618,15 +47646,15 @@ class BaseSandboxAdapter {
   }
   async createDirectories(paths, options) {
     const polyfillService = this.requirePolyfillService("createDirectories", "Directory creation not supported by this provider");
-    await polyfillService.createDirectories(paths, options);
+    await polyfillService.createDirectories(paths.map((p) => this.normalizePath(p)), options);
   }
   async deleteDirectories(paths, options) {
     const polyfillService = this.requirePolyfillService("deleteDirectories", "Directory deletion not supported by this provider");
-    await polyfillService.deleteDirectories(paths, options);
+    await polyfillService.deleteDirectories(paths.map((p) => this.normalizePath(p)), options);
   }
   async listDirectory(path) {
     const polyfillService = this.requirePolyfillService("listDirectory", "Directory listing not supported by this provider");
-    return polyfillService.listDirectory(path);
+    return polyfillService.listDirectory(this.normalizePath(path));
   }
   async* readFileStream(path) {
     this.requirePolyfillService("readFileStream", "File stream read not supported by this provider");
@@ -47678,7 +47706,7 @@ class BaseSandboxAdapter {
   }
   async getFileInfo(paths) {
     const polyfillService = this.requirePolyfillService("getFileInfo", "File info not supported by this provider");
-    return polyfillService.getFileInfo(paths);
+    return polyfillService.getFileInfo(paths.map((p) => this.normalizePath(p)));
   }
   async setPermissions(entries) {
     const polyfillService = this.requirePolyfillService("setPermissions", "Permission setting not supported by this provider");
@@ -47686,7 +47714,7 @@ class BaseSandboxAdapter {
   }
   async search(pattern, path) {
     const polyfillService = this.requirePolyfillService("search", "File search not supported by this provider");
-    return polyfillService.search(pattern, path);
+    return polyfillService.search(pattern, path !== undefined ? this.normalizePath(path) : path);
   }
   async ping() {
     const polyfillService = this.requirePolyfillService("ping", "Health check not supported by this provider");
@@ -47809,6 +47837,9 @@ class DevboxApi {
 class SealosDevboxAdapter extends BaseSandboxAdapter {
   config;
   provider = "sealosdevbox";
+  get rootPath() {
+    return "/home/devbox/workspace";
+  }
   api;
   _id;
   constructor(config) {
@@ -47838,18 +47869,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
         return "Error";
     }
   }
-  async waitUntilDeleted() {
-    const startTime = Date.now();
-    const checkInterval = 1000;
-    while (Date.now() - startTime < 120000) {
-      const data = await this.getInfo().catch(() => true);
-      if (!data) {
-        return;
-      }
-      await this.sleep(checkInterval);
-    }
-    throw new TimeoutError("Sandbox not deleted", 120000, "waitUntilDeleted");
-  }
   async getInfo() {
     try {
       const res = await this.api.info(this._id);
@@ -47940,7 +47959,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
     }
   }
   async execute(command, options) {
-    const cmd = this.buildCommand(command, options?.workingDirectory);
+    const cmd = this.buildCommand(command, this.normalizePath(options?.workingDirectory));
     try {
       const res = await this.api.exec(this._id, {
         command: cmd,
@@ -47979,8 +47998,8 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   runtime;
   _sandbox;
   _connection;
-  _id = "";
-  constructor(connectionConfig = {}, createConfig) {
+  _id;
+  constructor(connectionConfig, createConfig) {
     super();
     this.connectionConfig = connectionConfig;
     this.createConfig = createConfig;
@@ -47988,9 +48007,17 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     this._connection = this.createConnectionConfig();
     this.polyfillService = new CommandPolyfillService(this);
   }
+  get rootPath() {
+    const mountPath = this.createConfig.volumes?.[0]?.mountPath;
+    return mountPath ? mountPath.replace(/\/+$/, "") : "/home/sandbox";
+  }
   get id() {
     return this._id;
   }
+  set sandbox(sandbox) {
+    this._sandbox = sandbox;
+    this._id = sandbox?.id;
+  }
   get sandbox() {
     if (!this._sandbox) {
       throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
@@ -47999,9 +48026,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   }
   createConnectionConfig() {
     const { baseUrl, apiKey, requestTimeoutSeconds, debug, useServerProxy } = this.connectionConfig;
-    if (!baseUrl) {
-      return new import_opensandbox.ConnectionConfig({ apiKey, requestTimeoutSeconds, debug, useServerProxy });
-    }
     return new import_opensandbox.ConnectionConfig({
       domain: baseUrl,
       apiKey,
@@ -48112,32 +48136,74 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return 0;
   }
+  async getSandboxBySessionId() {
+    const manager = import_opensandbox.SandboxManager.create({ connectionConfig: this._connection });
+    const result = await manager.listSandboxInfos({
+      metadata: { sessionId: this.connectionConfig.sessionId }
+    });
+    const val = result.items[0];
+    if (val) {
+      const status = this.mapStatus(val.status);
+      return {
+        id: val.id,
+        status
+      };
+    }
+  }
   async ensureRunning() {
-    return this.create();
+    const sandbox = await this.getSandboxBySessionId();
+    if (sandbox) {
+      switch (sandbox.status.state) {
+        case "UnExist":
+          await this.create();
+          break;
+        case "Running":
+          await this.connect(sandbox.id);
+          break;
+        case "Creating":
+        case "Starting":
+          await this.waitUntilReady();
+          break;
+        case "Stopping":
+        case "Stopped":
+          await this.resume(sandbox.id);
+          break;
+        case "Deleting":
+          await this.waitUntilDeleted();
+          await this.create();
+          break;
+        case "Error":
+          throw new ConnectionError(`Sandbox error: ${sandbox.status.message}`);
+        default:
+          throw new ConnectionError(`Sandbox state ${sandbox.status.state} not supported`);
+      }
+    } else {
+      await this.create();
+    }
   }
   async create() {
-    if (!this.createConfig) {
-      throw new Error("createConfig is required to create a sandbox. Pass it as the third argument to createSandbox().");
-    }
     const cfg = this.createConfig;
     try {
       this._status = { state: "Creating" };
       const image = this.convertImageSpec(cfg.image);
       const resource = this.convertResourceLimits(cfg.resourceLimits);
-      this._sandbox = await import_opensandbox.Sandbox.create({
+      this.sandbox = await import_opensandbox.Sandbox.create({
         connectionConfig: this._connection,
         image,
         entrypoint: cfg.entrypoint,
         timeoutSeconds: cfg.timeoutSeconds ?? null,
         resource,
         env: cfg.env,
-        metadata: cfg.metadata,
+        metadata: {
+          ...cfg.metadata,
+          sessionId: this.connectionConfig.sessionId
+        },
         volumes: cfg.volumes,
         skipHealthCheck: cfg.skipHealthCheck,
         readyTimeoutSeconds: cfg.readyTimeoutSeconds,
         healthCheckPollingInterval: cfg.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
@@ -48147,31 +48213,51 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async connect(sandboxId) {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await import_opensandbox.Sandbox.connect({
+      this.sandbox = await import_opensandbox.Sandbox.connect({
         sandboxId,
         connectionConfig: this._connection,
         skipHealthCheck: this.createConfig?.skipHealthCheck,
         readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
         healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
       });
-      this._id = this._sandbox.id;
       this._status = { state: "Running" };
     } catch (error) {
       this._status = { state: "Error", message: String(error) };
       throw new ConnectionError(`Failed to connect to sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
     }
   }
+  async resume(sandboxId) {
+    try {
+      this._status = { state: "Starting" };
+      this.sandbox = await import_opensandbox.Sandbox.resume({
+        sandboxId,
+        connectionConfig: this._connection,
+        skipHealthCheck: this.createConfig?.skipHealthCheck,
+        readyTimeoutSeconds: this.createConfig?.readyTimeoutSeconds,
+        healthCheckPollingInterval: this.createConfig?.healthCheckPollingInterval
+      });
+      this._status = { state: "Running" };
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError(`Failed to resume sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
+    }
+  }
   async start() {
     try {
       this._status = { state: "Starting" };
-      this._sandbox = await this.sandbox.resume();
-      this._id = this.sandbox.id;
+      this.sandbox = await this.sandbox.resume();
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+      const code = error instanceof import_opensandbox.SandboxException ? error.error.code : undefined;
+      switch (code) {
+        case "DOCKER::SANDBOX_NOT_PAUSED":
+          return;
+        case "SANDBOX::API_NOT_SUPPORTED":
+          throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
+        default:
+          throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
       }
-      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
     }
   }
   async stop() {
@@ -48180,6 +48266,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       await this.sandbox.pause();
       this._status = { state: "Stopped" };
     } catch (error) {
+      const message = error instanceof import_opensandbox.SandboxException ? error.error.message : undefined;
+      if (message?.includes("already paused")) {
+        return;
+      }
       if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
         throw new FeatureNotSupportedError("Stop/pause not supported by this runtime", "stop", this.provider);
       }
@@ -48190,43 +48280,38 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     try {
       this._status = { state: "Deleting" };
       await this.sandbox.kill();
-      this._sandbox = undefined;
-      this._id = "";
+      this.sandbox = undefined;
       this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
   async close() {
-    if (this._sandbox) {
-      await this._sandbox.close();
-    }
+    await this.sandbox.close();
   }
   async getEndpoint(port) {
     const sdkEndpoint = await this.sandbox.getEndpoint(port);
-    return this.convertSdkEndpoint(sdkEndpoint, port);
-  }
-  convertSdkEndpoint(sdkEndpoint, requestedPort) {
     const raw = sdkEndpoint.endpoint;
     const colonIdx = raw.lastIndexOf(":");
     const hasPathBeforeColon = colonIdx !== -1 && raw.slice(0, colonIdx).includes("/");
     if (colonIdx !== -1 && !hasPathBeforeColon) {
       const host = raw.slice(0, colonIdx);
       const parsedPort = parseInt(raw.slice(colonIdx + 1), 10);
-      const port = isNaN(parsedPort) ? requestedPort : parsedPort;
+      const portNumber = isNaN(parsedPort) ? port : parsedPort;
       const protocol = port === 443 ? "https" : "http";
-      return { host, port, protocol, url: `${protocol}://${raw}` };
+      return { host, port: portNumber, protocol, url: `${protocol}://${raw}` };
     }
     return {
       host: raw,
-      port: requestedPort,
+      port,
       protocol: "https",
       url: `https://${raw}`
     };
   }
   async getInfo() {
-    if (!this._sandbox)
+    if (!this._sandbox) {
       return null;
+    }
     try {
       const info = await this.sandbox.getInfo();
       return {
@@ -48253,7 +48338,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async execute(command, options) {
     try {
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: options?.background
       });
       const stdout = execution.logs.stdout.map((msg) => msg.text).join(`
@@ -48290,7 +48375,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
         } : {}
       };
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: options?.background
       }, sdkHandlers);
       if (handlers.onComplete) {
@@ -48312,7 +48397,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async executeBackground(command, options) {
     try {
       const execution = await this.sandbox.commands.run(command, {
-        workingDirectory: options?.workingDirectory,
+        workingDirectory: this.normalizePath(options?.workingDirectory),
         background: true
       });
       if (!execution.id) {
@@ -48360,6 +48445,9 @@ var import_code_interpreter = __toESM(require_dist4(), 1);
 class E2BAdapter extends BaseSandboxAdapter {
   config;
   provider = "e2b";
+  get rootPath() {
+    return "/home/user";
+  }
   sandbox = null;
   _id;
   constructor(config) {
@@ -48489,7 +48577,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     try {
       const sandbox = await this.ensureSandbox();
       const result = await sandbox.commands.run(command, {
-        cwd: options?.workingDirectory,
+        cwd: this.normalizePath(options?.workingDirectory),
         timeoutMs: options?.timeoutMs
       });
       return {
@@ -48512,7 +48600,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       const results = [];
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         try {
           const content = await sandbox.files.read(path);
           results.push({
@@ -48549,7 +48637,7 @@ class E2BAdapter extends BaseSandboxAdapter {
           data = "";
         }
         return {
-          path: f.path,
+          path: this.normalizePath(f.path),
           data
         };
       });
@@ -48588,7 +48676,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       const results = [];
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         try {
           await sandbox.files.remove(path);
           results.push({
@@ -48613,7 +48701,7 @@ class E2BAdapter extends BaseSandboxAdapter {
     const sandbox = await this.ensureSandbox();
     try {
       for (const { source, destination } of moves) {
-        await sandbox.files.rename(source, destination);
+        await sandbox.files.rename(this.normalizePath(source), this.normalizePath(destination));
       }
     } catch (error) {
       throw new CommandExecutionError("Failed to move files", "moveFiles", error instanceof Error ? error : undefined);
@@ -48622,7 +48710,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async createDirectories(paths) {
     const sandbox = await this.ensureSandbox();
     try {
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         await sandbox.files.makeDir(path);
       }
     } catch (error) {
@@ -48632,7 +48720,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async deleteDirectories(paths) {
     const sandbox = await this.ensureSandbox();
     try {
-      for (const path of paths) {
+      for (const path of paths.map((p) => this.normalizePath(p))) {
         await sandbox.files.remove(path);
       }
     } catch (error) {
@@ -48642,7 +48730,7 @@ class E2BAdapter extends BaseSandboxAdapter {
   async listDirectory(path) {
     const sandbox = await this.ensureSandbox();
     try {
-      const entries = await sandbox.files.list(path);
+      const entries = await sandbox.files.list(this.normalizePath(path));
       return entries.map((entry) => {
         const isDirectory = entry.type === import_code_interpreter.FileType.DIR;
         return {

package/dist/interfaces/ISandboxLifecycle.d.ts

@@ -5,7 +5,7 @@ import type { SandboxId, SandboxInfo, SandboxStatus } from '../types';
  */
 export interface ISandboxLifecycle {
     /** Unique identifier for this sandbox */
-    readonly id: SandboxId;
+    readonly id?: SandboxId;
     /** Current status of the sandbox */
     readonly status: SandboxStatus;
     /**
@@ -39,6 +39,7 @@ export interface ISandboxLifecycle {
      * @throws {SandboxReadyTimeoutError} If timeout is exceeded
      */
     waitUntilReady(timeoutMs?: number): Promise<void>;
+    waitUntilDeleted(timeoutMs?: number): Promise<void>;
     /**
      * Renew the sandbox expiration, extending its lifetime.
      * Not all providers support this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastgpt-sdk/sandbox-adapter",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Unified abstraction layer for cloud sandbox providers with adapter pattern and feature polyfilling",
   "type": "module",
   "main": "./dist/index.cjs",