@fastgpt-sdk/sandbox-adapter 0.0.1

package/dist/index.js

@@ -0,0 +1,1225 @@
+// src/adapters/FastGPTSandboxAdapter/index.ts
+import {
+  createSDK
+} from "@fastgpt-sdk/sandbox-server";
+
+// src/errors/SandboxException.ts
+class SandboxException extends Error {
+  code;
+  constructor(message, code = "INTERNAL_UNKNOWN_ERROR", cause) {
+    super(message, { cause });
+    this.code = code;
+    this.name = "SandboxException";
+    Object.setPrototypeOf(this, SandboxException.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause,
+      stack: this.stack
+    };
+  }
+}
+
+// src/errors/CommandExecutionError.ts
+class CommandExecutionError extends SandboxException {
+  command;
+  exitCode;
+  stdout;
+  stderr;
+  commandError;
+  constructor(message, command, exitCodeOrCause, stdout, stderr) {
+    super(message, "COMMAND_FAILED", exitCodeOrCause instanceof Error ? exitCodeOrCause : undefined);
+    this.command = command;
+    this.name = "CommandExecutionError";
+    Object.setPrototypeOf(this, CommandExecutionError.prototype);
+    if (exitCodeOrCause instanceof Error) {
+      this.commandError = exitCodeOrCause;
+    } else {
+      this.exitCode = exitCodeOrCause;
+      this.stdout = stdout;
+      this.stderr = stderr;
+    }
+  }
+  getCombinedOutput() {
+    let output = this.stdout || "";
+    if (this.stderr) {
+      output += output ? `
+${this.stderr}` : this.stderr;
+    }
+    return output;
+  }
+}
+// src/errors/ConnectionError.ts
+class ConnectionError extends SandboxException {
+  endpoint;
+  constructor(message, endpoint, cause) {
+    super(message, "CONNECTION_ERROR", cause);
+    this.endpoint = endpoint;
+    this.name = "ConnectionError";
+    Object.setPrototypeOf(this, ConnectionError.prototype);
+  }
+}
+// src/errors/FeatureNotSupportedError.ts
+class FeatureNotSupportedError extends SandboxException {
+  feature;
+  provider;
+  constructor(message, feature, provider) {
+    super(`Feature not supported by ${provider}: ${message}`, "FEATURE_NOT_SUPPORTED");
+    this.feature = feature;
+    this.provider = provider;
+    this.name = "FeatureNotSupportedError";
+    Object.setPrototypeOf(this, FeatureNotSupportedError.prototype);
+  }
+}
+// src/errors/FileOperationError.ts
+class FileOperationError extends SandboxException {
+  path;
+  fileErrorCode;
+  constructor(message, path, fileErrorCode, cause) {
+    super(message, fileErrorCode, cause);
+    this.path = path;
+    this.fileErrorCode = fileErrorCode;
+    this.name = "FileOperationError";
+    Object.setPrototypeOf(this, FileOperationError.prototype);
+  }
+}
+// src/errors/SandboxStateError.ts
+class SandboxStateError extends SandboxException {
+  currentState;
+  requiredState;
+  constructor(message, currentState, requiredState) {
+    super(`Invalid sandbox state: ${message} (current: ${currentState}${requiredState ? `, required: ${requiredState}` : ""})`, "INVALID_STATE");
+    this.currentState = currentState;
+    this.requiredState = requiredState;
+    this.name = "SandboxStateError";
+    Object.setPrototypeOf(this, SandboxStateError.prototype);
+  }
+}
+// src/errors/TimeoutError.ts
+class TimeoutError extends SandboxException {
+  timeoutMs;
+  operation;
+  constructor(message, timeoutMs, operation) {
+    super(message, "TIMEOUT");
+    this.timeoutMs = timeoutMs;
+    this.operation = operation;
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+
+class SandboxReadyTimeoutError extends SandboxException {
+  constructor(sandboxId, timeoutMs) {
+    super(`Sandbox ${sandboxId} did not become ready within ${timeoutMs}ms`, "READY_TIMEOUT");
+    this.name = "SandboxReadyTimeoutError";
+    Object.setPrototypeOf(this, SandboxReadyTimeoutError.prototype);
+  }
+}
+// src/utils/base64.ts
+function bytesToBase64(bytes) {
+  const binary = Array.from(bytes).map((b) => String.fromCharCode(b)).join("");
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64.trim());
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// src/polyfill/CommandPolyfillService.ts
+class CommandPolyfillService {
+  executor;
+  constructor(executor) {
+    this.executor = executor;
+  }
+  async readFile(path) {
+    try {
+      const result = await this.executor.execute(`cat "${this.escapePath(path)}" | base64 -w 0`);
+      if (result.exitCode !== 0) {
+        throw this.createFileError(path, result.stderr);
+      }
+      return base64ToBytes(result.stdout);
+    } catch (error) {
+      if (error instanceof FileOperationError) {
+        throw error;
+      }
+      if (error instanceof CommandExecutionError) {
+        throw this.createFileError(path, error.stderr || "");
+      }
+      throw error;
+    }
+  }
+  async readFileRange(path, start, end) {
+    const length = end ? end - start : "";
+    const cmd = `dd if="${this.escapePath(path)}" bs=1 skip=${start} count=${length} 2>/dev/null | base64 -w 0`;
+    const result = await this.executor.execute(cmd);
+    if (result.exitCode !== 0) {
+      throw this.createFileError(path, result.stderr);
+    }
+    return base64ToBytes(result.stdout);
+  }
+  async writeFile(path, data) {
+    const base64 = bytesToBase64(data);
+    const chunkSize = 1024;
+    await this.createParentDirectory(path);
+    let first = true;
+    for (let i = 0;i < base64.length; i += chunkSize) {
+      const chunk = base64.slice(i, i + chunkSize);
+      const redirect = first ? ">" : ">>";
+      const result = await this.executor.execute(`echo "${chunk}" | base64 -d ${redirect} "${this.escapePath(path)}"`);
+      if (result.exitCode !== 0) {
+        throw this.createFileError(path, result.stderr);
+      }
+      first = false;
+    }
+    return data.length;
+  }
+  async writeTextFile(path, content) {
+    await this.createParentDirectory(path);
+    const escapedContent = content.replace(/\\/g, "\\\\").replace(/\$/g, "\\$");
+    const result = await this.executor.execute(`cat > "${this.escapePath(path)}" << 'POLYFILL_EOF'
+${escapedContent}
+POLYFILL_EOF`);
+    if (result.exitCode !== 0) {
+      throw this.createFileError(path, result.stderr);
+    }
+    return content.length;
+  }
+  async deleteFiles(paths) {
+    const results = [];
+    for (const path of paths) {
+      try {
+        const result = await this.executor.execute(`rm -f "${this.escapePath(path)}"`);
+        results.push({
+          path,
+          success: result.exitCode === 0,
+          error: result.exitCode !== 0 ? new Error(result.stderr) : undefined
+        });
+      } catch (error) {
+        results.push({
+          path,
+          success: false,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return results;
+  }
+  async createDirectories(paths, options) {
+    for (const path of paths) {
+      const result = await this.executor.execute(`mkdir -p "${this.escapePath(path)}"`);
+      if (result.exitCode !== 0) {
+        throw new FileOperationError(`Failed to create directory: ${result.stderr}`, path, "PATH_NOT_DIRECTORY");
+      }
+      if (options?.mode) {
+        await this.executor.execute(`chmod ${options.mode.toString(8)} "${this.escapePath(path)}"`);
+      }
+      if (options?.owner || options?.group) {
+        const owner = options.owner || "";
+        const group = options.group ? `:${options.group}` : "";
+        await this.executor.execute(`chown ${owner}${group} "${this.escapePath(path)}" 2>/dev/null || true`);
+      }
+    }
+  }
+  async deleteDirectories(paths, options) {
+    const flagParts = [];
+    if (options?.recursive !== false)
+      flagParts.push("r");
+    if (options?.force !== false)
+      flagParts.push("f");
+    const flags = flagParts.length > 0 ? `-${flagParts.join("")}` : "";
+    for (const path of paths) {
+      const result = await this.executor.execute(`rm ${flags} "${this.escapePath(path)}"`.trim());
+      if (result.exitCode !== 0) {
+        throw new FileOperationError(`Failed to delete directory: ${result.stderr}`, path, "PATH_IS_DIRECTORY");
+      }
+    }
+  }
+  async listDirectory(path) {
+    const result = await this.executor.execute(`ls -la "${this.escapePath(path)}" --time-style=+"%Y-%m-%dT%H:%M:%S" 2>/dev/null || echo "DIRECTORY_NOT_FOUND"`);
+    if (result.stdout.includes("DIRECTORY_NOT_FOUND")) {
+      throw new FileOperationError("Directory not found", path, "FILE_NOT_FOUND");
+    }
+    return this.parseLsOutput(result.stdout, path);
+  }
+  async createParentDirectory(filePath) {
+    const lastSlash = filePath.lastIndexOf("/");
+    if (lastSlash > 0) {
+      const parentDir = filePath.slice(0, lastSlash);
+      await this.executor.execute(`mkdir -p "${this.escapePath(parentDir)}"`);
+    }
+  }
+  async getFileInfo(paths) {
+    const infoMap = new Map;
+    for (const path of paths) {
+      try {
+        const result = await this.executor.execute(`stat -c '%s|%Y|%W|%a|%U|%G|%F' "${this.escapePath(path)}" 2>/dev/null || echo "STAT_FAILED"`);
+        if (result.stdout.includes("STAT_FAILED")) {
+          continue;
+        }
+        const parts = result.stdout.trim().split("|");
+        if (parts.length >= 7) {
+          infoMap.set(path, {
+            path,
+            size: Number.parseInt(parts[0], 10) || undefined,
+            modifiedAt: parts[1] ? new Date(Number.parseInt(parts[1], 10) * 1000) : undefined,
+            createdAt: parts[2] ? new Date(Number.parseInt(parts[2], 10) * 1000) : undefined,
+            mode: Number.parseInt(parts[3], 8) || undefined,
+            owner: parts[4] || undefined,
+            group: parts[5] || undefined,
+            isDirectory: parts[6].includes("directory"),
+            isFile: parts[6].includes("regular file"),
+            isSymlink: parts[6].includes("symbolic link")
+          });
+        }
+      } catch {}
+    }
+    return infoMap;
+  }
+  async setPermissions(entries) {
+    for (const entry of entries) {
+      if (entry.mode !== undefined) {
+        await this.executor.execute(`chmod ${entry.mode.toString(8)} "${this.escapePath(entry.path)}"`);
+      }
+      if (entry.owner || entry.group) {
+        const owner = entry.owner || "";
+        const group = entry.group ? `:${entry.group}` : "";
+        await this.executor.execute(`chown ${owner}${group} "${this.escapePath(entry.path)}" 2>/dev/null || true`);
+      }
+    }
+  }
+  async search(pattern, path = ".") {
+    const escapedPattern = pattern.replace(/'/g, `'"'"'`);
+    const escapedPath = this.escapePath(path);
+    let result = await this.executor.execute(`find "${escapedPath}" -name '${escapedPattern}' -print 2>/dev/null || echo "FIND_FAILED"`);
+    if (!result.stdout.includes("FIND_FAILED")) {
+      return result.stdout.split(`
+`).filter((p) => p.trim()).map((p) => ({ path: p }));
+    }
+    result = await this.executor.execute(`ls -R "${escapedPath}" 2>/dev/null | grep -E "${escapedPattern}" || true`);
+    return result.stdout.split(`
+`).filter((p) => p.trim()).map((p) => ({ path: `${path}/${p}` }));
+  }
+  async moveFiles(entries) {
+    for (const { source, destination } of entries) {
+      const result = await this.executor.execute(`mv "${this.escapePath(source)}" "${this.escapePath(destination)}"`);
+      if (result.exitCode !== 0) {
+        throw new FileOperationError(`Failed to move file: ${result.stderr}`, source, "TRANSFER_ERROR");
+      }
+    }
+  }
+  async replaceContent(entries) {
+    for (const { path, oldContent, newContent } of entries) {
+      const escapedOld = oldContent.replace(/\\/g, "\\\\\\\\").replace(/\//g, "\\/").replace(/&/g, "\\&");
+      const escapedNew = newContent.replace(/\\/g, "\\\\\\\\").replace(/\//g, "\\/").replace(/&/g, "\\&");
+      const result = await this.executor.execute(`sed -i 's/${escapedOld}/${escapedNew}/g' "${this.escapePath(path)}"`);
+      if (result.exitCode !== 0) {
+        throw new FileOperationError(`Failed to replace content: ${result.stderr}`, path, "INVALID_PATH");
+      }
+    }
+  }
+  async ping() {
+    try {
+      const result = await this.executor.execute('echo "PING"');
+      return result.exitCode === 0 && result.stdout.includes("PING");
+    } catch {
+      return false;
+    }
+  }
+  async getMetrics() {
+    const timestamp = Date.now();
+    const cpuResult = await this.executor.execute('nproc 2>/dev/null || echo "1"');
+    const cpuCount = Number.parseInt(cpuResult.stdout.trim(), 10) || 1;
+    const memResult = await this.executor.execute('cat /proc/meminfo 2>/dev/null || echo "FAILED"');
+    let memoryTotalMiB = 0;
+    let memoryUsedMiB = 0;
+    if (!memResult.stdout.includes("FAILED")) {
+      const totalMatch = memResult.stdout.match(/MemTotal:\s+(\d+)\s+kB/);
+      const availableMatch = memResult.stdout.match(/MemAvailable:\s+(\d+)\s+kB/);
+      if (totalMatch) {
+        memoryTotalMiB = Math.floor(Number.parseInt(totalMatch[1], 10) / 1024);
+      }
+      if (totalMatch && availableMatch) {
+        const total = Number.parseInt(totalMatch[1], 10);
+        const available = Number.parseInt(availableMatch[1], 10);
+        memoryUsedMiB = Math.floor((total - available) / 1024);
+      }
+    }
+    const cpuUsedPercentage = 0;
+    return {
+      cpuCount,
+      cpuUsedPercentage,
+      memoryTotalMiB,
+      memoryUsedMiB,
+      timestamp
+    };
+  }
+  escapePath(path) {
+    return path.replace(/"/g, "\\\"");
+  }
+  parseLsOutput(output, basePath) {
+    const lines = output.split(`
+`);
+    const entries = [];
+    for (const line of lines) {
+      if (line.startsWith("total") || !line.trim()) {
+        continue;
+      }
+      const match = line.match(/^([-dl])([-rwxsStT]{9})\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\s+(.+)$/);
+      if (match) {
+        const [, type, , size, dateStr, name] = match;
+        if (name === "." || name === "..") {
+          continue;
+        }
+        const isDirectory = type === "d";
+        const isSymlink = type === "l";
+        entries.push({
+          name,
+          path: `${basePath}/${name}`,
+          isDirectory: isDirectory || isSymlink,
+          isFile: type === "-",
+          size: Number.parseInt(size, 10) || undefined,
+          modifiedAt: new Date(dateStr)
+        });
+      }
+    }
+    return entries;
+  }
+  createFileError(path, stderr) {
+    const lowerStderr = stderr.toLowerCase();
+    if (lowerStderr.includes("no such file") || lowerStderr.includes("does not exist")) {
+      return new FileOperationError(stderr, path, "FILE_NOT_FOUND");
+    }
+    if (lowerStderr.includes("permission denied")) {
+      return new FileOperationError(stderr, path, "PERMISSION_DENIED");
+    }
+    if (lowerStderr.includes("is a directory")) {
+      return new FileOperationError(stderr, path, "PATH_IS_DIRECTORY");
+    }
+    if (lowerStderr.includes("not a directory")) {
+      return new FileOperationError(stderr, path, "PATH_NOT_DIRECTORY");
+    }
+    return new FileOperationError(stderr, path, "TRANSFER_ERROR");
+  }
+}
+
+// src/adapters/BaseSandboxAdapter.ts
+class BaseSandboxAdapter {
+  _status = { state: "Creating" };
+  polyfillService;
+  constructor() {
+    this.polyfillService = new CommandPolyfillService(this);
+  }
+  get status() {
+    return this._status;
+  }
+  async waitUntilReady(timeoutMs = 120000) {
+    const startTime = Date.now();
+    const checkInterval = 1000;
+    while (Date.now() - startTime < timeoutMs) {
+      const isReady = await this.ping();
+      if (isReady) {
+        return;
+      }
+      await this.sleep(checkInterval);
+    }
+    throw new SandboxReadyTimeoutError(this.id, timeoutMs);
+  }
+  async renewExpiration(_additionalSeconds) {
+    throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
+  }
+  async executeStream(command, handlers, options) {
+    const result = await this.execute(command, options);
+    if (handlers.onStdout && result.stdout) {
+      await handlers.onStdout({ text: result.stdout });
+    }
+    if (handlers.onStderr && result.stderr) {
+      await handlers.onStderr({ text: result.stderr });
+    }
+    if (handlers.onComplete) {
+      await handlers.onComplete(result);
+    }
+  }
+  async executeBackground(_command, _options) {
+    throw new FeatureNotSupportedError("Background execution not supported by this provider", "executeBackground", this.provider);
+  }
+  async interrupt(_sessionId) {
+    throw new FeatureNotSupportedError("Command interruption not supported by this provider", "interrupt", this.provider);
+  }
+  async readFiles(paths, options) {
+    const polyfillService = this.requirePolyfillService("readFiles", "File read not supported by this provider");
+    const results = [];
+    for (const path of paths) {
+      try {
+        let content;
+        if (options?.range) {
+          const [startValue, endValue] = options.range.split("-");
+          const start = Number.parseInt(startValue, 10);
+          const end = endValue ? Number.parseInt(endValue, 10) : undefined;
+          if (Number.isNaN(start) || endValue && Number.isNaN(end)) {
+            throw new Error(`Invalid range: ${options.range}`);
+          }
+          content = await polyfillService.readFileRange(path, start, end);
+        } else {
+          content = await polyfillService.readFile(path);
+        }
+        results.push({ path, content, error: null });
+      } catch (error) {
+        results.push({
+          path,
+          content: new Uint8Array,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return results;
+  }
+  async writeFiles(entries) {
+    const polyfillService = this.requirePolyfillService("writeFiles", "File write not supported by this provider");
+    const results = [];
+    for (const entry of entries) {
+      try {
+        let bytesWritten;
+        if (typeof entry.data === "string") {
+          bytesWritten = await polyfillService.writeTextFile(entry.path, entry.data);
+        } else if (entry.data instanceof Uint8Array) {
+          bytesWritten = await polyfillService.writeFile(entry.path, entry.data);
+        } else if (entry.data instanceof ArrayBuffer) {
+          bytesWritten = await polyfillService.writeFile(entry.path, new Uint8Array(entry.data));
+        } else if (entry.data instanceof Blob) {
+          const arrayBuffer = await entry.data.arrayBuffer();
+          bytesWritten = await polyfillService.writeFile(entry.path, new Uint8Array(arrayBuffer));
+        } else {
+          const chunks = [];
+          const reader = entry.data.getReader();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            chunks.push(value);
+          }
+          const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+          const combined = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            combined.set(chunk, offset);
+            offset += chunk.length;
+          }
+          bytesWritten = await polyfillService.writeFile(entry.path, combined);
+        }
+        results.push({ path: entry.path, bytesWritten, error: null });
+      } catch (error) {
+        results.push({
+          path: entry.path,
+          bytesWritten: 0,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+    return results;
+  }
+  async deleteFiles(paths) {
+    const polyfillService = this.requirePolyfillService("deleteFiles", "File delete not supported by this provider");
+    const polyfillResults = await polyfillService.deleteFiles(paths);
+    return polyfillResults.map((r) => ({
+      path: r.path,
+      success: r.success,
+      error: r.error || null
+    }));
+  }
+  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 })));
+  }
+  async replaceContent(entries) {
+    const polyfillService = this.requirePolyfillService("replaceContent", "Content replace not supported by this provider");
+    await polyfillService.replaceContent(entries);
+  }
+  async createDirectories(paths, options) {
+    const polyfillService = this.requirePolyfillService("createDirectories", "Directory creation not supported by this provider");
+    await polyfillService.createDirectories(paths, options);
+  }
+  async deleteDirectories(paths, options) {
+    const polyfillService = this.requirePolyfillService("deleteDirectories", "Directory deletion not supported by this provider");
+    await polyfillService.deleteDirectories(paths, options);
+  }
+  async listDirectory(path) {
+    const polyfillService = this.requirePolyfillService("listDirectory", "Directory listing not supported by this provider");
+    return polyfillService.listDirectory(path);
+  }
+  async* readFileStream(path) {
+    this.requirePolyfillService("readFileStream", "File stream read not supported by this provider");
+    const readChunk = async (range) => {
+      const results = await this.readFiles([path], range ? { range } : undefined);
+      const fileResult = results[0];
+      if (!fileResult) {
+        throw new Error("No file result returned");
+      }
+      if (fileResult.error) {
+        throw fileResult.error;
+      }
+      return fileResult.content;
+    };
+    let size;
+    try {
+      const infoMap = await this.getFileInfo([path]);
+      size = infoMap.get(path)?.size;
+    } catch {}
+    if (typeof size !== "number") {
+      yield await readChunk();
+      return;
+    }
+    const chunkSize = 64 * 1024;
+    for (let offset = 0;offset < size; offset += chunkSize) {
+      const end = Math.min(offset + chunkSize, size);
+      const content = await readChunk(`${offset}-${end}`);
+      yield content;
+    }
+  }
+  async writeFileStream(path, stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    await this.writeFiles([{ path, data: combined }]);
+  }
+  async getFileInfo(paths) {
+    const polyfillService = this.requirePolyfillService("getFileInfo", "File info not supported by this provider");
+    return polyfillService.getFileInfo(paths);
+  }
+  async setPermissions(entries) {
+    const polyfillService = this.requirePolyfillService("setPermissions", "Permission setting not supported by this provider");
+    await polyfillService.setPermissions(entries);
+  }
+  async search(pattern, path) {
+    const polyfillService = this.requirePolyfillService("search", "File search not supported by this provider");
+    return polyfillService.search(pattern, path);
+  }
+  async ping() {
+    const polyfillService = this.requirePolyfillService("ping", "Health check not supported by this provider");
+    return polyfillService.ping();
+  }
+  async getMetrics() {
+    const polyfillService = this.requirePolyfillService("getMetrics", "Metrics not supported by this provider");
+    return polyfillService.getMetrics();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  requirePolyfillService(feature, message) {
+    if (!this.polyfillService) {
+      throw new FeatureNotSupportedError(message, feature, this.provider);
+    }
+    return this.polyfillService;
+  }
+}
+
+// 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" };
+  }
+}
+
+class FastGPTSandboxAdapter extends BaseSandboxAdapter {
+  config;
+  provider = "fastgpt";
+  sdk;
+  _id = "";
+  constructor(config) {
+    super();
+    this.config = config;
+    this.sdk = createSDK(config.baseUrl, config.token);
+    this._id = config.containerName;
+  }
+  get id() {
+    return this._id;
+  }
+  async getInfo() {
+    try {
+      const info = await this.sdk.container.get(this._id);
+      if (!info) {
+        return null;
+      }
+      this._status = mapContainerStatus(info.status.state);
+      return {
+        id: info.name,
+        image: {
+          repository: info.image.imageName
+        },
+        entrypoint: [],
+        status: mapContainerStatus(info.status.state),
+        createdAt: info.createdAt ? new Date(info.createdAt) : new Date
+      };
+    } catch (error) {
+      throw new CommandExecutionError("Failed to get sandbox info", "getInfo", error instanceof Error ? error : undefined);
+    }
+  }
+  async create(_config) {
+    try {
+      const exists = await this.getInfo();
+      if (exists) {
+        return;
+      }
+      this._status = { state: "Creating" };
+      await this.sdk.container.create({ name: 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" };
+    } catch (error) {
+      throw new CommandExecutionError("Failed to pause sandbox", "pause", error instanceof Error ? error : undefined);
+    }
+  }
+  async resume() {
+    try {
+      await this.sdk.container.start(this._id);
+      this._status = { state: "Running" };
+    } catch (error) {
+      throw new CommandExecutionError("Failed to resume sandbox", "resume", error instanceof Error ? error : undefined);
+    }
+  }
+  async delete() {
+    try {
+      await this.sdk.container.delete(this._id);
+      this._status = { state: "Deleted" };
+    } 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
+      });
+      return {
+        stdout: response.stdout,
+        stderr: response.stderr,
+        exitCode: response.exitCode
+      };
+    } catch (error) {
+      throw new CommandExecutionError(`Command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
+    }
+  }
+  async ping() {
+    try {
+      return await this.sdk.sandbox.health(this._id);
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/adapters/MinimalProviderAdapter.ts
+class MinimalProviderAdapter extends BaseSandboxAdapter {
+  config;
+  provider = "minimal";
+  _id = "";
+  connection;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get id() {
+    return this._id;
+  }
+  get status() {
+    return this._status;
+  }
+  async create(config) {
+    if (this.config?.connectionFactory) {
+      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");
+    }
+  }
+  async connect(connection) {
+    this.connection = connection;
+    this._id = connection.id;
+    this._status = await connection.getStatus();
+  }
+  async start() {
+    this._status = { state: "Running" };
+  }
+  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);
+  }
+  async delete() {
+    await this.stop();
+    await this.connection?.close();
+  }
+  async getInfo() {
+    return {
+      id: this._id,
+      image: { repository: "minimal", tag: "latest" },
+      entrypoint: [],
+      status: this._status,
+      createdAt: new Date
+    };
+  }
+  async close() {
+    await this.connection?.close();
+  }
+  async execute(command, options) {
+    if (!this.connection) {
+      throw new Error("Not connected to minimal provider");
+    }
+    let finalCommand = command;
+    if (options?.workingDirectory) {
+      finalCommand = `cd "${options.workingDirectory}" && ${command}`;
+    }
+    if (options?.timeoutMs && options.timeoutMs > 0) {
+      const timeoutSec = Math.ceil(options.timeoutMs / 1000);
+      finalCommand = `timeout ${timeoutSec} sh -c '${finalCommand.replace(/'/g, `'"'"'`)}'`;
+    }
+    if (options?.env && Object.keys(options.env).length > 0) {
+      const envVars = Object.entries(options.env).map(([k, v]) => `${k}="${v.replace(/"/g, '"')}"`).join(" ");
+      finalCommand = `export ${envVars} && ${finalCommand}`;
+    }
+    const result = await this.connection.execute(finalCommand);
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    };
+  }
+}
+
+// src/adapters/OpenSandboxAdapter.ts
+import { ConnectionConfig, Sandbox } from "@alibaba-group/opensandbox";
+class OpenSandboxAdapter extends BaseSandboxAdapter {
+  connectionConfig;
+  provider = "opensandbox";
+  runtime;
+  _sandbox;
+  _connection;
+  _id = "";
+  _connectionState = "disconnected";
+  constructor(connectionConfig = {}) {
+    super();
+    this.connectionConfig = connectionConfig;
+    this.runtime = connectionConfig.runtime ?? "docker";
+    this._connection = this.createConnectionConfig();
+  }
+  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");
+    }
+    return this._sandbox;
+  }
+  createConnectionConfig() {
+    const { baseUrl, apiKey } = this.connectionConfig;
+    if (!baseUrl) {
+      return new ConnectionConfig({ apiKey });
+    }
+    return new ConnectionConfig({
+      domain: baseUrl,
+      apiKey
+    });
+  }
+  convertImageSpec(image) {
+    const parts = [image.repository];
+    if (image.tag) {
+      parts.push(":", image.tag);
+    }
+    if (image.digest) {
+      parts.push("@", image.digest);
+    }
+    return parts.join("");
+  }
+  parseImageSpec(image) {
+    const atIndex = image.indexOf("@");
+    if (atIndex > -1) {
+      const repository = image.slice(0, atIndex);
+      const digest = image.slice(atIndex + 1);
+      return { repository, digest };
+    }
+    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 };
+  }
+  convertResourceLimits(resourceLimits) {
+    if (!resourceLimits) {
+      return;
+    }
+    const result = {};
+    if (resourceLimits.cpuCount !== undefined) {
+      result.cpu = resourceLimits.cpuCount.toString();
+    }
+    if (resourceLimits.memoryMiB !== undefined) {
+      result.memory = `${resourceLimits.memoryMiB}Mi`;
+    }
+    if (resourceLimits.diskGiB !== undefined) {
+      result.disk = `${resourceLimits.diskGiB}Gi`;
+    }
+    return result;
+  }
+  parseResourceLimits(resource) {
+    if (!resource) {
+      return;
+    }
+    const result = {};
+    const cpu = resource.cpu;
+    if (cpu) {
+      const cpuCount = Number.parseInt(cpu, 10);
+      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;
+        }
+      }
+    }
+    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;
+      }
+    }
+    return result;
+  }
+  async create(config) {
+    this._connectionState = "connecting";
+    try {
+      const image = this.convertImageSpec(config.image);
+      const resource = this.convertResourceLimits(config.resourceLimits);
+      this._sandbox = await Sandbox.create({
+        connectionConfig: this._connection,
+        image,
+        entrypoint: config.entrypoint,
+        timeoutSeconds: config.timeout,
+        resource,
+        env: config.env,
+        metadata: config.metadata
+      });
+      this._id = this._sandbox.id;
+      this._status = { state: "Running" };
+      this._connectionState = "connected";
+    } catch (error) {
+      this._connectionState = "disconnected";
+      throw new ConnectionError("Failed to create sandbox", this.connectionConfig.baseUrl, error);
+    }
+  }
+  async connect(sandboxId) {
+    this._connectionState = "connecting";
+    try {
+      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";
+      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" };
+    } 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 CommandExecutionError("Failed to pause sandbox", "pause", error instanceof Error ? error : undefined);
+    }
+  }
+  async resume() {
+    try {
+      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("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);
+    }
+  }
+  async delete() {
+    try {
+      await this.sandbox.kill();
+      this._status = { state: "Deleted" };
+      this._connectionState = "disconnected";
+    } catch (error) {
+      throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
+    }
+  }
+  async getInfo() {
+    try {
+      const info = await this.sandbox.getInfo();
+      return {
+        id: info.id,
+        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,
+        createdAt: info.createdAt,
+        expiresAt: info.expiresAt,
+        resourceLimits: this.parseResourceLimits(info.resourceLimits)
+      };
+    } catch (error) {
+      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);
+    } catch (error) {
+      throw new CommandExecutionError("Failed to renew sandbox expiration", "renew", error instanceof Error ? error : undefined);
+    }
+  }
+  async execute(command, options) {
+    try {
+      const execution = await this.sandbox.commands.run(command, {
+        workingDirectory: options?.workingDirectory,
+        background: options?.background
+      });
+      const stdout = execution.logs.stdout.map((msg) => msg.text).join(`
+`);
+      const stderr = execution.logs.stderr.map((msg) => msg.text).join(`
+`);
+      const exitCode = 0;
+      const stdoutLength = execution.logs.stdout.reduce((sum, msg) => sum + msg.text.length, 0);
+      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
+      };
+    } catch (error) {
+      if (error instanceof SandboxStateError) {
+        throw error;
+      }
+      throw new CommandExecutionError(`Command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
+    }
+  }
+  async executeStream(command, handlers, options) {
+    try {
+      const sdkHandlers = {
+        ...handlers.onStderr ? { onStderr: handlers.onStderr } : {},
+        ...handlers.onStdout ? { onStdout: handlers.onStdout } : {},
+        ...handlers.onError ? {
+          onError: async (err) => {
+            const error = new Error(err.value || err.name || "Execution error");
+            error.name = err.name || "ExecutionError";
+            if (err.traceback?.length) {
+              error.stack = err.traceback.join(`
+`);
+            }
+            await handlers.onError?.(error);
+          }
+        } : {}
+      };
+      const execution = await this.sandbox.commands.run(command, {
+        workingDirectory: options?.workingDirectory,
+        background: options?.background
+      }, sdkHandlers);
+      if (handlers.onComplete) {
+        const stdout = execution.logs.stdout.map((msg) => msg.text).join(`
+`);
+        const stderr = execution.logs.stderr.map((msg) => msg.text).join(`
+`);
+        const exitCode = 0;
+        const stdoutLength = execution.logs.stdout.reduce((sum, msg) => sum + msg.text.length, 0);
+        const stderrLength = execution.logs.stderr.reduce((sum, msg) => sum + msg.text.length, 0);
+        const MaxOutputSize = 1024 * 1024;
+        const truncated = stdoutLength >= MaxOutputSize || stderrLength >= MaxOutputSize;
+        await handlers.onComplete({ stdout, stderr, exitCode, truncated });
+      }
+    } catch (error) {
+      throw new CommandExecutionError(`Streaming command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
+    }
+  }
+  async executeBackground(command, options) {
+    try {
+      const execution = await this.sandbox.commands.run(command, {
+        workingDirectory: options?.workingDirectory,
+        background: true
+      });
+      if (!execution.id) {
+        throw new CommandExecutionError("Background execution did not return a session ID", command);
+      }
+      const sessionId = execution.id;
+      const sandbox = this.sandbox;
+      return {
+        sessionId,
+        kill: async () => {
+          try {
+            await sandbox.commands.interrupt(sessionId);
+          } catch (error) {
+            throw new CommandExecutionError(`Failed to kill background session ${sessionId}`, "interrupt", error instanceof Error ? error : undefined);
+          }
+        }
+      };
+    } catch (error) {
+      if (error instanceof CommandExecutionError) {
+        throw error;
+      }
+      throw new CommandExecutionError(`Background command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
+    }
+  }
+  async interrupt(sessionId) {
+    try {
+      await this.sandbox.commands.interrupt(sessionId);
+    } catch (error) {
+      throw new CommandExecutionError(`Failed to interrupt session ${sessionId}`, "interrupt", error instanceof Error ? error : undefined);
+    }
+  }
+  async ping() {
+    try {
+      return await this.sandbox.health.ping();
+    } catch {
+      return false;
+    }
+  }
+  async getMetrics() {
+    return this.sandbox.metrics.getMetrics();
+  }
+}
+
+// src/adapters/index.ts
+var createSandbox = ({ provider, config }) => {
+  switch (provider) {
+    case "opensandbox":
+      return new OpenSandboxAdapter(config);
+    case "minimal":
+      return new MinimalProviderAdapter(config);
+    case "fastgpt":
+      return new FastGPTSandboxAdapter(config);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+};
+export {
+  createSandbox,
+  TimeoutError,
+  SandboxStateError,
+  SandboxReadyTimeoutError,
+  SandboxException,
+  OpenSandboxAdapter,
+  MinimalProviderAdapter,
+  FileOperationError,
+  FeatureNotSupportedError,
+  FastGPTSandboxAdapter,
+  ConnectionError,
+  CommandExecutionError,
+  BaseSandboxAdapter
+};