@fastgpt-sdk/sandbox-adapter 0.0.6 → 0.0.8

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -1,6 +1,6 @@
 import type { ISandbox } from '../interfaces/ISandbox';
 import { CommandPolyfillService } from '../polyfill/CommandPolyfillService';
-import type { ContentReplaceEntry, DirectoryEntry, ExecuteOptions, ExecuteResult, FileDeleteResult, FileInfo, FileReadResult, FileWriteEntry, FileWriteResult, MoveEntry, PermissionEntry, ReadFileOptions, SandboxConfig, SandboxId, SandboxInfo, SandboxMetrics, SandboxStatus, SearchResult, StreamHandlers } from '../types';
+import type { ContentReplaceEntry, DirectoryEntry, ExecuteOptions, ExecuteResult, FileDeleteResult, FileInfo, FileReadResult, FileWriteEntry, FileWriteResult, MoveEntry, PermissionEntry, ReadFileOptions, SandboxId, SandboxInfo, SandboxMetrics, SandboxStatus, SearchResult, StreamHandlers } from '../types';
 /**
  * Abstract base class for all sandbox adapters.
  *
@@ -8,14 +8,15 @@ import type { ContentReplaceEntry, DirectoryEntry, ExecuteOptions, ExecuteResult
  * search, health, and metrics operations via CommandPolyfillService.
  * Subclasses can override the polyfill service in their constructor.
  */
-export declare abstract class BaseSandboxAdapter implements ISandbox {
+export declare abstract class BaseSandboxAdapter<TSandboxConfig = unknown> implements ISandbox<TSandboxConfig> {
     abstract readonly id: SandboxId;
     abstract readonly provider: string;
     protected _status: SandboxStatus;
     protected polyfillService?: CommandPolyfillService;
     constructor();
     get status(): SandboxStatus;
-    abstract create(config: SandboxConfig): Promise<void>;
+    abstract ensureRunning(config?: TSandboxConfig): Promise<void>;
+    abstract create(config?: TSandboxConfig): Promise<void>;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
     abstract delete(): Promise<void>;

package/dist/adapters/{OpenSandboxAdapter.d.ts → OpenSandboxAdapter/index.d.ts}

@@ -1,5 +1,6 @@
-import type { ExecuteOptions, ExecuteResult, SandboxConfig, SandboxId, SandboxInfo, SandboxMetrics, StreamHandlers } from '../types';
-import { BaseSandboxAdapter } from './BaseSandboxAdapter';
+import type { ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo, SandboxMetrics, StreamHandlers } from '@/types';
+import { BaseSandboxAdapter } from '../BaseSandboxAdapter';
+import { OpenSandboxConfigType } from './type';
 /**
  * Sandbox runtime type.
  * - docker: Full-featured runtime with pause/resume support
@@ -40,7 +41,7 @@ export interface OpenSandboxConnectionConfig {
  * console.log(result.stdout); // v18.x.x
  * ```
  */
-export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
+export declare class OpenSandboxAdapter extends BaseSandboxAdapter<OpenSandboxConfigType> {
     private connectionConfig;
     readonly provider: "opensandbox";
     readonly runtime: SandboxRuntimeType;
@@ -57,7 +58,8 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private parseImageSpec;
     private convertResourceLimits;
     private parseResourceLimits;
-    create(config: SandboxConfig): Promise<void>;
+    ensureRunning(config: OpenSandboxConfigType): Promise<void>;
+    create(config: OpenSandboxConfigType): Promise<void>;
     connect(sandboxId: string): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

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

@@ -0,0 +1,22 @@
+import { ImageSpec, NetworkPolicy, ResourceLimits } from '@/types';
+/**
+ * Configuration for creating a sandbox.
+ */
+export interface OpenSandboxConfigType {
+    /** Container image specification */
+    image: ImageSpec;
+    /** Entrypoint command */
+    entrypoint?: string[];
+    /** Timeout in seconds (0 for no timeout) */
+    timeout?: number;
+    /** Resource limits */
+    resourceLimits?: ResourceLimits;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Metadata for the sandbox */
+    metadata?: Record<string, any>;
+    /** Network access policy */
+    networkPolicy?: NetworkPolicy;
+    /** Provider-specific extensions */
+    extensions?: Record<string, unknown>;
+}

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

@@ -1,4 +1,4 @@
-import type { ExecuteOptions, ExecuteResult, SandboxConfig, SandboxId, SandboxInfo } from '../../types';
+import type { ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo } from '../../types';
 import { BaseSandboxAdapter } from '../BaseSandboxAdapter';
 /**
  * Configuration for Sealos Devbox Adapter.
@@ -20,7 +20,8 @@ export declare class SealosDevboxAdapter extends BaseSandboxAdapter {
     private StatusAdapt;
     private waitUntilDeleted;
     getInfo(): Promise<SandboxInfo | null>;
-    create(_config: SandboxConfig): Promise<void>;
+    ensureRunning(): Promise<void>;
+    create(): Promise<void>;
     stop(): Promise<void>;
     start(): Promise<void>;
     delete(): Promise<void>;

package/dist/adapters/index.d.ts

@@ -1,17 +1,12 @@
-import { ISandbox } from '../interfaces';
 import { type SealosDevboxConfig } from './SealosDevboxAdapter';
-import { type MinimalProviderConfig } from './MinimalProviderAdapter';
 import { type OpenSandboxConnectionConfig } from './OpenSandboxAdapter';
-export { BaseSandboxAdapter } from './BaseSandboxAdapter';
+import { ISandbox } from '@/interfaces';
 export { SealosDevboxAdapter, type SealosDevboxConfig } from './SealosDevboxAdapter';
-export { MinimalProviderAdapter, type MinimalProviderConfig, type MinimalProviderConnection } from './MinimalProviderAdapter';
 export { OpenSandboxAdapter, type OpenSandboxConnectionConfig, type SandboxRuntimeType } from './OpenSandboxAdapter';
+export type SandboxProvider = 'opensandbox' | 'sealos-devbox';
 type CreateProviderType = {
     provider: 'opensandbox';
     config: OpenSandboxConnectionConfig;
-} | {
-    provider: 'minimal';
-    config: MinimalProviderConfig;
 } | {
     provider: 'sealos-devbox';
     config: SealosDevboxConfig;
@@ -23,4 +18,4 @@ type CreateProviderType = {
  * @returns Configured sandbox instance
  * @throws Error if provider type is unknown
  */
-export declare const createSandbox: ({ provider, config }: CreateProviderType) => ISandbox;
+export declare const createSandbox: ({ provider, config }: CreateProviderType) => ISandbox<unknown>;

package/dist/index.js

@@ -776,7 +776,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
       throw new CommandExecutionError("Failed to get sandbox info", "getInfo", error instanceof Error ? error : undefined);
     }
   }
-  async create(_config) {
+  async ensureRunning() {
     try {
       const sandbox = await this.getInfo();
       if (sandbox) {
@@ -794,13 +794,21 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
             return;
           case "Deleting":
             await this.waitUntilDeleted();
+            await this.create();
+            return;
           default:
             throw new ConnectionError(`Failed to create sandbox: ${status}, ${sandbox.status.message}`);
         }
       }
+      await this.create();
+    } catch (error) {
+      throw new ConnectionError("Failed to ensure sandbox running", this.config.baseUrl, error);
+    }
+  }
+  async create() {
+    try {
       this._status = { state: "Creating" };
       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);
@@ -837,7 +845,6 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
   }
   async execute(command, options) {
     try {
-      await this.waitUntilReady();
       const cmd = options?.workingDirectory ? ["sh", "-lc", `cd ${options.workingDirectory} && ${command}`] : ["sh", "-lc", command];
       const res = await this.api.exec(this._id, {
         command: cmd,
@@ -867,91 +874,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
   }
 }
 
-// src/adapters/MinimalProviderAdapter.ts
-class MinimalProviderAdapter extends BaseSandboxAdapter {
-  config;
-  provider = "minimal";
-  _id = "";
-  connection;
-  constructor(config) {
-    super();
-    this.config = config;
-    this.polyfillService = new CommandPolyfillService(this);
-  }
-  get id() {
-    return this._id;
-  }
-  async create(config) {
-    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(" "));
-      }
-    } catch (error) {
-      this._status = { state: "Error", message: String(error) };
-      throw new ConnectionError("Failed to create sandbox", undefined, error);
-    }
-  }
-  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(() => {});
-    await this.connection?.close();
-    this._status = { state: "Stopped" };
-  }
-  async delete() {
-    await this.stop();
-    this._status = { state: "UnExist" };
-  }
-  async getInfo() {
-    if (!this.connection)
-      return null;
-    return {
-      id: this._id,
-      image: { repository: "minimal", tag: "latest" },
-      entrypoint: [],
-      status: this._status,
-      createdAt: new Date
-    };
-  }
-  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
+// src/adapters/OpenSandboxAdapter/index.ts
 import { ConnectionConfig, Sandbox } from "@alibaba-group/opensandbox";
 class OpenSandboxAdapter extends BaseSandboxAdapter {
   connectionConfig;
@@ -1067,6 +990,9 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return result;
   }
+  async ensureRunning(config) {
+    return this.create(config);
+  }
   async create(config) {
     try {
       this._status = { state: "Creating" };
@@ -1271,8 +1197,6 @@ var createSandbox = ({ provider, config }) => {
   switch (provider) {
     case "opensandbox":
       return new OpenSandboxAdapter(config);
-    case "minimal":
-      return new MinimalProviderAdapter(config);
     case "sealos-devbox":
       return new SealosDevboxAdapter(config);
     default:
@@ -1287,10 +1211,8 @@ export {
   SandboxReadyTimeoutError,
   SandboxException,
   OpenSandboxAdapter,
-  MinimalProviderAdapter,
   FileOperationError,
   FeatureNotSupportedError,
   ConnectionError,
-  CommandExecutionError,
-  BaseSandboxAdapter
+  CommandExecutionError
 };

package/dist/interfaces/ISandbox.d.ts

@@ -12,7 +12,7 @@ import type { ISandboxLifecycle } from './ISandboxLifecycle';
  * Following Interface Segregation Principle, this interface
  * is composed of smaller, focused interfaces.
  */
-export interface ISandbox extends ISandboxLifecycle, ICommandExecution, IFileSystem, IHealthCheck {
+export interface ISandbox<TSandboxConfig = unknown> extends ISandboxLifecycle<TSandboxConfig>, ICommandExecution, IFileSystem, IHealthCheck {
     /** Provider name (e.g., 'opensandbox') */
     readonly provider: string;
 }

package/dist/interfaces/ISandboxLifecycle.d.ts

@@ -1,18 +1,22 @@
-import type { SandboxConfig, SandboxId, SandboxInfo, SandboxStatus } from '../types';
+import type { SandboxId, SandboxInfo, SandboxStatus } from '../types';
 /**
  * Interface for sandbox lifecycle operations.
  * Follows Interface Segregation Principle - only lifecycle methods.
  */
-export interface ISandboxLifecycle {
+export interface ISandboxLifecycle<TSandboxConfig = unknown> {
     /** Unique identifier for this sandbox */
     readonly id: SandboxId;
     /** Current status of the sandbox */
     readonly status: SandboxStatus;
+    /**
+     * Ensure the sandbox is running.
+     */
+    ensureRunning(config?: TSandboxConfig): Promise<void>;
     /**
      * Create a new sandbox with the given configuration.
      * The sandbox ID is assigned after creation.
      */
-    create(config: SandboxConfig): Promise<void>;
+    create(config?: TSandboxConfig): Promise<void>;
     /**
      * Start a stopped sandbox.
      */

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export type { BackgroundExecution, ExecuteOptions, ExecuteResult, OutputMessage, StreamHandlers } from './execution';
 export type { ContentReplaceEntry, DirectoryEntry, FileDeleteResult, FileInfo, FileReadResult, FileWriteEntry, FileWriteResult, MoveEntry, PermissionEntry, ReadFileOptions, SearchResult } from './filesystem';
-export type { Endpoint, ImageSpec, NetworkPolicy, ResourceLimits, SandboxConfig, SandboxId, SandboxInfo, SandboxMetrics, SandboxState, SandboxStatus } from './sandbox';
+export type { Endpoint, ImageSpec, NetworkPolicy, ResourceLimits, SandboxId, SandboxInfo, SandboxMetrics, SandboxState, SandboxStatus } from './sandbox';

package/dist/types/sandbox.d.ts

@@ -37,27 +37,6 @@ export interface NetworkPolicy {
     allowEgress?: boolean;
     allowedHosts?: string[];
 }
-/**
- * Configuration for creating a sandbox.
- */
-export interface SandboxConfig {
-    /** Container image specification */
-    image: ImageSpec;
-    /** Entrypoint command */
-    entrypoint?: string[];
-    /** Timeout in seconds (0 for no timeout) */
-    timeout?: number;
-    /** Resource limits */
-    resourceLimits?: ResourceLimits;
-    /** Environment variables */
-    env?: Record<string, string>;
-    /** Metadata for the sandbox */
-    metadata?: Record<string, any>;
-    /** Network access policy */
-    networkPolicy?: NetworkPolicy;
-    /** Provider-specific extensions */
-    extensions?: Record<string, unknown>;
-}
 /**
  * Information about a sandbox.
  */

package/package.json

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

package/dist/adapters/MinimalProviderAdapter.d.ts

@@ -1,46 +0,0 @@
-import type { ExecuteOptions, ExecuteResult, SandboxConfig, SandboxId, SandboxInfo, SandboxStatus } from '../types';
-import { BaseSandboxAdapter } from './BaseSandboxAdapter';
-/**
- * Connection interface for minimal providers.
- * Represents a provider that only supports basic command execution.
- */
-export interface MinimalProviderConnection {
-    /** Unique identifier for the sandbox */
-    id: string;
-    /** Execute a command and return result */
-    execute(command: string): Promise<{
-        stdout: string;
-        stderr: string;
-        exitCode: number;
-    }>;
-    /** Get current status */
-    getStatus(): Promise<SandboxStatus>;
-    close(): Promise<void>;
-}
-export type MinimalProviderConfig = {
-    connectionFactory?: () => Promise<MinimalProviderConnection>;
-};
-/**
- * Minimal provider adapter.
- *
- * Adapts a provider with minimal capabilities (only command execution)
- * to the full ISandbox interface using the CommandPolyfillService.
- *
- * Use case: Legacy SSH-based sandboxes, custom container providers,
- * or any provider that only exposes a shell interface.
- */
-export declare class MinimalProviderAdapter extends BaseSandboxAdapter {
-    private config?;
-    readonly provider = "minimal";
-    private _id;
-    private connection?;
-    constructor(config?: MinimalProviderConfig | undefined);
-    get id(): SandboxId;
-    create(config: SandboxConfig): Promise<void>;
-    connect(connection: MinimalProviderConnection): Promise<void>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    delete(): Promise<void>;
-    getInfo(): Promise<SandboxInfo | null>;
-    execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
-}