@fastgpt-sdk/sandbox-adapter 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,8 +1,3 @@
-// src/adapters/FastGPTSandboxAdapter/index.ts
-import {
-  createSDK
-} from "@fastgpt-sdk/sandbox-server";
-
 // src/errors/SandboxException.ts
 class SandboxException extends Error {
   code;
@@ -413,9 +408,7 @@ POLYFILL_EOF`);
 class BaseSandboxAdapter {
   _status = { state: "Creating" };
   polyfillService;
-  constructor() {
-    this.polyfillService = new CommandPolyfillService(this);
-  }
+  constructor() {}
   get status() {
     return this._status;
   }
@@ -633,52 +626,151 @@ class BaseSandboxAdapter {
   }
 }
 
-// src/adapters/FastGPTSandboxAdapter/index.ts
-function mapContainerStatus(state) {
-  switch (state) {
-    case "Running":
-      return { state: "Running" };
-    case "Creating":
-      return { state: "Creating" };
-    case "Paused":
-      return { state: "Paused" };
-    case "Error":
-      return { state: "Error" };
-    case "Unknown":
-    default:
-      return { state: "Error", reason: "Unknown state" };
+// src/adapters/SealosDevboxAdapter/api.ts
+class DevboxApi {
+  baseUrl;
+  token;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.token = config.token;
+  }
+  url(path, params) {
+    const u = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        u.searchParams.set(k, v);
+      }
+    }
+    return u.toString();
+  }
+  async request(input, init) {
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${this.token}`);
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    const res = await fetch(input, { ...init, headers });
+    return await res.json();
+  }
+  async create(name) {
+    return this.request(this.url("/api/v1/devbox"), {
+      method: "POST",
+      body: JSON.stringify({ name })
+    });
+  }
+  async info(name) {
+    return this.request(this.url(`/api/v1/devbox/${name}`), {
+      method: "GET"
+    });
+  }
+  async pause(name) {
+    return this.request(this.url(`/api/v1/devbox/${name}/pause`), {
+      method: "POST"
+    });
+  }
+  async resume(name) {
+    return this.request(this.url(`/api/v1/devbox/${name}/resume`), {
+      method: "POST"
+    });
+  }
+  async delete(name) {
+    return this.request(this.url(`/api/v1/devbox/${name}`), {
+      method: "DELETE"
+    });
+  }
+  async exec(name, req) {
+    return this.request(this.url(`/api/v1/devbox/${name}/exec`), {
+      method: "POST",
+      body: JSON.stringify(req)
+    });
+  }
+  async uploadFile(name, params, content) {
+    const queryParams = { path: params.path };
+    if (params.mode)
+      queryParams.mode = params.mode;
+    if (params.timeoutSeconds != null)
+      queryParams.timeoutSeconds = String(params.timeoutSeconds);
+    if (params.container)
+      queryParams.container = params.container;
+    return this.request(this.url(`/api/v1/devbox/${name}/files/upload`, queryParams), {
+      method: "POST",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: content
+    });
+  }
+  async downloadFile(name, params) {
+    const queryParams = { path: params.path };
+    if (params.filename)
+      queryParams.filename = params.filename;
+    if (params.timeoutSeconds != null)
+      queryParams.timeoutSeconds = String(params.timeoutSeconds);
+    if (params.container)
+      queryParams.container = params.container;
+    const res = await fetch(this.url(`/api/v1/devbox/${name}/files/download`, queryParams), {
+      headers: { Authorization: `Bearer ${this.token}` }
+    });
+    return res.arrayBuffer();
   }
 }
 
-class FastGPTSandboxAdapter extends BaseSandboxAdapter {
+// src/adapters/SealosDevboxAdapter/index.ts
+class SealosDevboxAdapter extends BaseSandboxAdapter {
   config;
-  provider = "fastgpt";
-  sdk;
-  _id = "";
+  provider = "sealos-devbox";
+  api;
+  _id;
   constructor(config) {
     super();
     this.config = config;
-    this.sdk = createSDK(config.baseUrl, config.token);
-    this._id = config.containerName;
+    this.api = new DevboxApi({ baseUrl: config.baseUrl, token: config.token });
+    this._id = config.sandboxId;
+    this.polyfillService = new CommandPolyfillService(this);
   }
   get id() {
     return this._id;
   }
+  StatusAdapt(data) {
+    if (data.deletionTimestamp) {
+      return "Deleting";
+    }
+    switch (data.state.phase) {
+      case "Running" /* Running */:
+        return "Running";
+      case "Pending" /* Pending */:
+        return "Creating";
+      case "Paused" /* Paused */:
+        return "Stopped";
+      case "Pausing" /* Pausing */:
+        return "Stopping";
+      default:
+        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 info = await this.sdk.container.get(this._id);
-      if (!info) {
+      const res = await this.api.info(this._id);
+      if (res.code !== 200)
         return null;
-      }
-      this._status = mapContainerStatus(info.status.state);
+      const data = res.data;
+      this._status = { state: this.StatusAdapt(data), message: res.message };
       return {
-        id: info.name,
-        image: {
-          repository: info.image.imageName
-        },
+        id: data.name,
+        image: { repository: "" },
         entrypoint: [],
-        status: mapContainerStatus(info.status.state),
-        createdAt: info.createdAt ? new Date(info.createdAt) : new Date
+        status: this._status,
+        createdAt: new Date
       };
     } catch (error) {
       throw new CommandExecutionError("Failed to get sandbox info", "getInfo", error instanceof Error ? error : undefined);
@@ -686,45 +778,48 @@ class FastGPTSandboxAdapter extends BaseSandboxAdapter {
   }
   async create(_config) {
     try {
-      const exists = await this.getInfo();
-      if (exists) {
-        return;
+      const sandbox = await this.getInfo();
+      if (sandbox) {
+        const status = sandbox.status.state;
+        switch (status) {
+          case "Running":
+            return;
+          case "Creating":
+          case "Starting":
+            await this.waitUntilReady();
+            return;
+          case "Stopping":
+          case "Stopped":
+            await this.start();
+            return;
+          case "Deleting":
+            await this.waitUntilDeleted();
+          default:
+            throw new ConnectionError(`Failed to create sandbox: ${status}, ${sandbox.status.message}`);
+        }
       }
       this._status = { state: "Creating" };
-      await this.sdk.container.create({ name: this._id });
+      await this.api.create(this._id);
       await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       throw new ConnectionError("Failed to create sandbox", this.config.baseUrl, error);
     }
   }
-  async start() {
-    try {
-      await this.sdk.container.start(this._id);
-      this._status = { state: "Running" };
-    } catch (error) {
-      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
-    }
-  }
   async stop() {
     try {
-      await this.sdk.container.pause(this._id);
-      this._status = { state: "Paused" };
-    } catch (error) {
-      throw new CommandExecutionError("Failed to stop sandbox", "stop", error instanceof Error ? error : undefined);
-    }
-  }
-  async pause() {
-    try {
-      await this.sdk.container.pause(this._id);
-      this._status = { state: "Paused" };
+      this._status = { state: "Stopping" };
+      await this.api.pause(this._id);
+      this._status = { state: "Stopped" };
     } catch (error) {
       throw new CommandExecutionError("Failed to pause sandbox", "pause", error instanceof Error ? error : undefined);
     }
   }
-  async resume() {
+  async start() {
     try {
-      await this.sdk.container.start(this._id);
+      this._status = { state: "Starting" };
+      await this.api.resume(this._id);
+      await this.waitUntilReady();
       this._status = { state: "Running" };
     } catch (error) {
       throw new CommandExecutionError("Failed to resume sandbox", "resume", error instanceof Error ? error : undefined);
@@ -732,26 +827,26 @@ class FastGPTSandboxAdapter extends BaseSandboxAdapter {
   }
   async delete() {
     try {
-      await this.sdk.container.delete(this._id);
-      this._status = { state: "Deleted" };
+      this._status = { state: "Deleting" };
+      await this.api.delete(this._id);
+      await this.waitUntilDeleted();
+      this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
-  async close() {
-    return this.delete();
-  }
   async execute(command, options) {
     try {
       await this.waitUntilReady();
-      const response = await this.sdk.sandbox.exec(this._id, {
-        command,
-        cwd: options?.workingDirectory
+      const cmd = options?.workingDirectory ? ["sh", "-lc", `cd ${options.workingDirectory} && ${command}`] : ["sh", "-lc", command];
+      const res = await this.api.exec(this._id, {
+        command: cmd,
+        timeoutSeconds: options?.timeoutMs ? Math.ceil(options.timeoutMs / 1000) : undefined
       });
       return {
-        stdout: response.stdout,
-        stderr: response.stderr,
-        exitCode: response.exitCode
+        stdout: res.data.stdout,
+        stderr: res.data.stderr,
+        exitCode: res.data.exitCode
       };
     } catch (error) {
       throw new CommandExecutionError(`Command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
@@ -759,7 +854,10 @@ class FastGPTSandboxAdapter extends BaseSandboxAdapter {
   }
   async ping() {
     try {
-      return await this.sdk.sandbox.health(this._id);
+      const res = await this.api.info(this._id);
+      if (res.code !== 200)
+        return false;
+      return res.data.state.phase === "Running" /* Running */;
     } catch {
       return false;
     }
@@ -775,23 +873,26 @@ class MinimalProviderAdapter extends BaseSandboxAdapter {
   constructor(config) {
     super();
     this.config = config;
+    this.polyfillService = new CommandPolyfillService(this);
   }
   get id() {
     return this._id;
   }
-  get status() {
-    return this._status;
-  }
   async create(config) {
-    if (this.config?.connectionFactory) {
+    if (!this.config?.connectionFactory) {
+      throw new ConnectionError("Connection factory not provided");
+    }
+    try {
+      this._status = { state: "Creating" };
       this.connection = await this.config.connectionFactory();
       this._id = this.connection.id;
       this._status = { state: "Running" };
       if (config.entrypoint && config.entrypoint.length > 0) {
         await this.execute(config.entrypoint.join(" "));
       }
-    } else {
-      throw new Error("Connection factory not provided");
+    } catch (error) {
+      this._status = { state: "Error", message: String(error) };
+      throw new ConnectionError("Failed to create sandbox", undefined, error);
     }
   }
   async connect(connection) {
@@ -804,19 +905,16 @@ class MinimalProviderAdapter extends BaseSandboxAdapter {
   }
   async stop() {
     await this.execute("exit 0").catch(() => {});
-    this._status = { state: "Deleted" };
-  }
-  async pause() {
-    throw new FeatureNotSupportedError("Pause not supported by minimal provider", "pause", this.provider);
-  }
-  async resume() {
-    throw new FeatureNotSupportedError("Resume not supported by minimal provider", "resume", this.provider);
+    await this.connection?.close();
+    this._status = { state: "Stopped" };
   }
   async delete() {
     await this.stop();
-    await this.connection?.close();
+    this._status = { state: "UnExist" };
   }
   async getInfo() {
+    if (!this.connection)
+      return null;
     return {
       id: this._id,
       image: { repository: "minimal", tag: "latest" },
@@ -825,9 +923,6 @@ class MinimalProviderAdapter extends BaseSandboxAdapter {
       createdAt: new Date
     };
   }
-  async close() {
-    await this.connection?.close();
-  }
   async execute(command, options) {
     if (!this.connection) {
       throw new Error("Not connected to minimal provider");
@@ -862,7 +957,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   _sandbox;
   _connection;
   _id = "";
-  _connectionState = "disconnected";
   constructor(connectionConfig = {}) {
     super();
     this.connectionConfig = connectionConfig;
@@ -872,12 +966,9 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   get id() {
     return this._id;
   }
-  get connectionState() {
-    return this._connectionState;
-  }
   get sandbox() {
     if (!this._sandbox) {
-      throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", this._connectionState, "connected");
+      throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
     }
     return this._sandbox;
   }
@@ -891,6 +982,25 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       apiKey
     });
   }
+  static STATE_MAP = {
+    running: "Running",
+    creating: "Creating",
+    starting: "Starting",
+    stopping: "Stopping",
+    stopped: "Stopped",
+    deleting: "Deleting",
+    error: "Error",
+    paused: "Stopped",
+    deleted: "UnExist"
+  };
+  mapStatus(sdkStatus) {
+    const state = OpenSandboxAdapter.STATE_MAP[sdkStatus.state.toLowerCase()] ?? "Error";
+    return {
+      state,
+      reason: sdkStatus.reason,
+      message: sdkStatus.message
+    };
+  }
   convertImageSpec(image) {
     const parts = [image.repository];
     if (image.tag) {
@@ -904,22 +1014,17 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   parseImageSpec(image) {
     const atIndex = image.indexOf("@");
     if (atIndex > -1) {
-      const repository = image.slice(0, atIndex);
-      const digest = image.slice(atIndex + 1);
-      return { repository, digest };
+      return { repository: image.slice(0, atIndex), digest: image.slice(atIndex + 1) };
     }
     const colonIndex = image.indexOf(":");
     if (colonIndex > -1) {
-      const repository = image.slice(0, colonIndex);
-      const tag = image.slice(colonIndex + 1);
-      return { repository, tag };
+      return { repository: image.slice(0, colonIndex), tag: image.slice(colonIndex + 1) };
     }
     return { repository: image };
   }
   convertResourceLimits(resourceLimits) {
-    if (!resourceLimits) {
+    if (!resourceLimits)
       return;
-    }
     const result = {};
     if (resourceLimits.cpuCount !== undefined) {
       result.cpu = resourceLimits.cpuCount.toString();
@@ -933,42 +1038,35 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     return result;
   }
   parseResourceLimits(resource) {
-    if (!resource) {
+    if (!resource)
       return;
-    }
     const result = {};
     const cpu = resource.cpu;
     if (cpu) {
       const cpuCount = Number.parseInt(cpu, 10);
-      if (!Number.isNaN(cpuCount)) {
+      if (!Number.isNaN(cpuCount))
         result.cpuCount = cpuCount;
-      }
     }
     const memory = resource.memory;
     if (memory) {
       const match = memory.match(/^(\d+)(Mi|Gi)$/);
       if (match) {
         const value = Number.parseInt(match[1] || "0", 10);
-        if (match[2] === "Mi") {
-          result.memoryMiB = value;
-        } else {
-          result.memoryMiB = value * 1024;
-        }
+        result.memoryMiB = match[2] === "Mi" ? value : value * 1024;
       }
     }
     const disk = resource.disk;
     if (disk) {
       const match = disk.match(/^(\d+)Gi$/);
       if (match) {
-        const value = Number.parseInt(match[1] || "0", 10);
-        result.diskGiB = value;
+        result.diskGiB = Number.parseInt(match[1] || "0", 10);
       }
     }
     return result;
   }
   async create(config) {
-    this._connectionState = "connecting";
     try {
+      this._status = { state: "Creating" };
       const image = this.convertImageSpec(config.image);
       const resource = this.convertResourceLimits(config.resourceLimits);
       this._sandbox = await Sandbox.create({
@@ -982,74 +1080,61 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       });
       this._id = this._sandbox.id;
       this._status = { state: "Running" };
-      this._connectionState = "connected";
     } catch (error) {
-      this._connectionState = "disconnected";
+      this._status = { state: "Error", message: String(error) };
       throw new ConnectionError("Failed to create sandbox", this.connectionConfig.baseUrl, error);
     }
   }
   async connect(sandboxId) {
-    this._connectionState = "connecting";
     try {
+      this._status = { state: "Starting" };
       this._sandbox = await Sandbox.connect({
         sandboxId,
         connectionConfig: this._connection
       });
       this._id = this._sandbox.id;
       this._status = { state: "Running" };
-      this._connectionState = "connected";
     } catch (error) {
-      this._connectionState = "disconnected";
+      this._status = { state: "Error", message: String(error) };
       throw new ConnectionError(`Failed to connect to sandbox ${sandboxId}`, this.connectionConfig.baseUrl, error);
     }
   }
   async start() {
-    if (this._status.state === "Paused") {
-      await this.resume();
-    }
-  }
-  async stop() {
-    try {
-      await this.sandbox.kill();
-      this._status = { state: "Deleted" };
-      this._connectionState = "disconnected";
-    } catch (error) {
-      throw new CommandExecutionError("Failed to stop sandbox", "stop", error instanceof Error ? error : undefined);
-    }
-  }
-  async pause() {
     try {
-      await this.sandbox.pause();
-      this._status = { state: "Paused" };
+      this._status = { state: "Starting" };
+      this._sandbox = await this.sandbox.resume();
+      this._id = this.sandbox.id;
+      this._status = { state: "Running" };
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Pause operation is not supported by this runtime (e.g., Kubernetes)", "pause", this.provider);
+        throw new FeatureNotSupportedError("Start/resume not supported by this runtime", "start", this.provider);
       }
-      throw new CommandExecutionError("Failed to pause sandbox", "pause", error instanceof Error ? error : undefined);
+      throw new CommandExecutionError("Failed to start sandbox", "start", error instanceof Error ? error : undefined);
     }
   }
-  async resume() {
+  async stop() {
     try {
-      this._sandbox = await this.sandbox.resume();
-      this._id = this.sandbox.id;
-      this._status = { state: "Running" };
+      this._status = { state: "Stopping" };
+      await this.sandbox.kill();
+      this._status = { state: "Stopped" };
     } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "SANDBOX::API_NOT_SUPPORTED") {
-        throw new FeatureNotSupportedError("Resume operation is not supported by this runtime (e.g., Kubernetes)", "resume", this.provider);
-      }
-      throw new CommandExecutionError("Failed to resume sandbox", "resume", error instanceof Error ? error : undefined);
+      throw new CommandExecutionError("Failed to stop sandbox", "stop", error instanceof Error ? error : undefined);
     }
   }
   async delete() {
     try {
+      this._status = { state: "Deleting" };
       await this.sandbox.kill();
-      this._status = { state: "Deleted" };
-      this._connectionState = "disconnected";
+      this._sandbox = undefined;
+      this._id = "";
+      this._status = { state: "UnExist" };
     } catch (error) {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
   async getInfo() {
+    if (!this._sandbox)
+      return null;
     try {
       const info = await this.sandbox.getInfo();
       return {
@@ -1057,7 +1142,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
         image: typeof info.image === "string" ? this.parseImageSpec(info.image) : ("uri" in info.image) ? this.parseImageSpec(info.image.uri) : info.image,
         entrypoint: info.entrypoint,
         metadata: info.metadata,
-        status: info.status,
+        status: this.mapStatus(info.status),
         createdAt: info.createdAt,
         expiresAt: info.expiresAt,
         resourceLimits: this.parseResourceLimits(info.resourceLimits)
@@ -1066,16 +1151,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       throw new CommandExecutionError("Failed to get sandbox info", "getInfo", error instanceof Error ? error : undefined);
     }
   }
-  async close() {
-    try {
-      await this._sandbox?.close();
-    } finally {
-      this._sandbox = undefined;
-      this._id = "";
-      this._connectionState = "closed";
-      this._status = { state: "Deleted" };
-    }
-  }
   async renewExpiration(additionalSeconds) {
     try {
       await this.sandbox.renew(additionalSeconds);
@@ -1098,16 +1173,10 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       const stderrLength = execution.logs.stderr.reduce((sum, msg) => sum + msg.text.length, 0);
       const MaxOutputSize = 1024 * 1024;
       const truncated = stdoutLength >= MaxOutputSize || stderrLength >= MaxOutputSize;
-      return {
-        stdout,
-        stderr,
-        exitCode,
-        truncated
-      };
+      return { stdout, stderr, exitCode, truncated };
     } catch (error) {
-      if (error instanceof SandboxStateError) {
+      if (error instanceof SandboxStateError)
         throw error;
-      }
       throw new CommandExecutionError(`Command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
     }
   }
@@ -1170,9 +1239,8 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
         }
       };
     } catch (error) {
-      if (error instanceof CommandExecutionError) {
+      if (error instanceof CommandExecutionError)
         throw error;
-      }
       throw new CommandExecutionError(`Background command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
     }
   }
@@ -1202,8 +1270,8 @@ var createSandbox = ({ provider, config }) => {
       return new OpenSandboxAdapter(config);
     case "minimal":
       return new MinimalProviderAdapter(config);
-    case "fastgpt":
-      return new FastGPTSandboxAdapter(config);
+    case "sealos-devbox":
+      return new SealosDevboxAdapter(config);
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
@@ -1211,6 +1279,7 @@ var createSandbox = ({ provider, config }) => {
 export {
   createSandbox,
   TimeoutError,
+  SealosDevboxAdapter,
   SandboxStateError,
   SandboxReadyTimeoutError,
   SandboxException,
@@ -1218,7 +1287,6 @@ export {
   MinimalProviderAdapter,
   FileOperationError,
   FeatureNotSupportedError,
-  FastGPTSandboxAdapter,
   ConnectionError,
   CommandExecutionError,
   BaseSandboxAdapter