@fastgpt-sdk/sandbox-adapter 0.0.8 → 0.0.10

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -8,15 +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<TSandboxConfig = unknown> implements ISandbox<TSandboxConfig> {
+export declare abstract class BaseSandboxAdapter implements ISandbox {
     abstract readonly id: SandboxId;
     abstract readonly provider: string;
     protected _status: SandboxStatus;
     protected polyfillService?: CommandPolyfillService;
     constructor();
     get status(): SandboxStatus;
-    abstract ensureRunning(config?: TSandboxConfig): Promise<void>;
-    abstract create(config?: TSandboxConfig): Promise<void>;
+    abstract ensureRunning(): Promise<void>;
+    abstract create(): Promise<void>;
     abstract start(): Promise<void>;
     abstract stop(): Promise<void>;
     abstract delete(): Promise<void>;

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

@@ -1,6 +1,7 @@
 import type { ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo, SandboxMetrics, StreamHandlers } from '@/types';
 import { BaseSandboxAdapter } from '../BaseSandboxAdapter';
-import { OpenSandboxConfigType } from './type';
+import type { OpenSandboxConfigType } from './type';
+export type { OpenSandboxConfigType } from './type';
 /**
  * Sandbox runtime type.
  * - docker: Full-featured runtime with pause/resume support
@@ -41,14 +42,15 @@ export interface OpenSandboxConnectionConfig {
  * console.log(result.stdout); // v18.x.x
  * ```
  */
-export declare class OpenSandboxAdapter extends BaseSandboxAdapter<OpenSandboxConfigType> {
+export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private connectionConfig;
+    private createConfig;
     readonly provider: "opensandbox";
     readonly runtime: SandboxRuntimeType;
     private _sandbox?;
     private _connection;
     private _id;
-    constructor(connectionConfig?: OpenSandboxConnectionConfig);
+    constructor(connectionConfig: OpenSandboxConnectionConfig | undefined, createConfig: OpenSandboxConfigType);
     get id(): SandboxId;
     private get sandbox();
     private createConnectionConfig;
@@ -58,8 +60,8 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter<OpenSandboxCo
     private parseImageSpec;
     private convertResourceLimits;
     private parseResourceLimits;
-    ensureRunning(config: OpenSandboxConfigType): Promise<void>;
-    create(config: OpenSandboxConfigType): Promise<void>;
+    ensureRunning(): Promise<void>;
+    create(): Promise<void>;
     connect(sandboxId: string): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

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

@@ -12,7 +12,7 @@ export interface SealosDevboxConfig {
 }
 export declare class SealosDevboxAdapter extends BaseSandboxAdapter {
     private config;
-    readonly provider: "sealos-devbox";
+    readonly provider: "sealosdevbox";
     private api;
     private _id;
     constructor(config: SealosDevboxConfig);

package/dist/adapters/index.d.ts

@@ -1,21 +1,25 @@
 import { type SealosDevboxConfig } from './SealosDevboxAdapter';
-import { type OpenSandboxConnectionConfig } from './OpenSandboxAdapter';
+import { type OpenSandboxConnectionConfig, type OpenSandboxConfigType } from './OpenSandboxAdapter';
 import { ISandbox } from '@/interfaces';
-export { SealosDevboxAdapter, type SealosDevboxConfig } from './SealosDevboxAdapter';
-export { OpenSandboxAdapter, type OpenSandboxConnectionConfig, type SandboxRuntimeType } from './OpenSandboxAdapter';
-export type SandboxProvider = 'opensandbox' | 'sealos-devbox';
-type CreateProviderType = {
-    provider: 'opensandbox';
-    config: OpenSandboxConnectionConfig;
-} | {
-    provider: 'sealos-devbox';
-    config: SealosDevboxConfig;
-};
+export type SandboxProviderType = 'opensandbox' | 'sealosdevbox';
+/** Maps each provider name to the ISandbox config type it exposes. */
+interface SandboxConfigMap {
+    opensandbox: OpenSandboxConfigType;
+    sealosdevbox: undefined;
+}
+/** Resolves the concrete ISandbox type for a given provider. */
+/** Maps each provider name to its constructor (connection) config type. */
+interface SandboxConnectionConfig {
+    opensandbox: OpenSandboxConnectionConfig;
+    sealosdevbox: SealosDevboxConfig;
+}
 /**
  * Create a sandbox provider instance.
+ * The return type is inferred from the provider name.
  *
  * @param config Provider configuration
  * @returns Configured sandbox instance
  * @throws Error if provider type is unknown
  */
-export declare const createSandbox: ({ provider, config }: CreateProviderType) => ISandbox<unknown>;
+export declare function createSandbox<P extends SandboxProviderType>(provider: P, config: SandboxConnectionConfig[P], createConfig: SandboxConfigMap[P]): ISandbox;
+export {};

package/dist/index.js

@@ -716,7 +716,7 @@ class DevboxApi {
 // src/adapters/SealosDevboxAdapter/index.ts
 class SealosDevboxAdapter extends BaseSandboxAdapter {
   config;
-  provider = "sealos-devbox";
+  provider = "sealosdevbox";
   api;
   _id;
   constructor(config) {
@@ -797,7 +797,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
             await this.create();
             return;
           default:
-            throw new ConnectionError(`Failed to create sandbox: ${status}, ${sandbox.status.message}`);
+            throw new ConnectionError(`Failed to ensure sandbox running: ${status}, ${sandbox.status.message}`);
         }
       }
       await this.create();
@@ -809,6 +809,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
     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);
@@ -844,8 +845,9 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
     }
   }
   async execute(command, options) {
+    const cmd = options?.workingDirectory ? ["sh", "-lc", `cd ${options.workingDirectory} && ${command}`] : ["sh", "-lc", command];
+    console.log(cmd, 2323);
     try {
-      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
@@ -878,14 +880,16 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
 import { ConnectionConfig, Sandbox } from "@alibaba-group/opensandbox";
 class OpenSandboxAdapter extends BaseSandboxAdapter {
   connectionConfig;
+  createConfig;
   provider = "opensandbox";
   runtime;
   _sandbox;
   _connection;
   _id = "";
-  constructor(connectionConfig = {}) {
+  constructor(connectionConfig = {}, createConfig) {
     super();
     this.connectionConfig = connectionConfig;
+    this.createConfig = createConfig;
     this.runtime = connectionConfig.runtime ?? "docker";
     this._connection = this.createConnectionConfig();
   }
@@ -990,22 +994,22 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     return result;
   }
-  async ensureRunning(config) {
-    return this.create(config);
+  async ensureRunning() {
+    return this.create();
   }
-  async create(config) {
+  async create() {
     try {
       this._status = { state: "Creating" };
-      const image = this.convertImageSpec(config.image);
-      const resource = this.convertResourceLimits(config.resourceLimits);
+      const image = this.convertImageSpec(this.createConfig.image);
+      const resource = this.convertResourceLimits(this.createConfig.resourceLimits);
       this._sandbox = await Sandbox.create({
         connectionConfig: this._connection,
         image,
-        entrypoint: config.entrypoint,
-        timeoutSeconds: config.timeout,
+        entrypoint: this.createConfig.entrypoint,
+        timeoutSeconds: this.createConfig.timeout,
         resource,
-        env: config.env,
-        metadata: config.metadata
+        env: this.createConfig.env,
+        metadata: this.createConfig.metadata
       });
       this._id = this._sandbox.id;
       this._status = { state: "Running" };
@@ -1193,24 +1197,22 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
 }
 
 // src/adapters/index.ts
-var createSandbox = ({ provider, config }) => {
+function createSandbox(provider, config, createConfig) {
   switch (provider) {
     case "opensandbox":
-      return new OpenSandboxAdapter(config);
-    case "sealos-devbox":
+      return new OpenSandboxAdapter(config, createConfig);
+    case "sealosdevbox":
       return new SealosDevboxAdapter(config);
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
-};
+}
 export {
   createSandbox,
   TimeoutError,
-  SealosDevboxAdapter,
   SandboxStateError,
   SandboxReadyTimeoutError,
   SandboxException,
-  OpenSandboxAdapter,
   FileOperationError,
   FeatureNotSupportedError,
   ConnectionError,

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<TSandboxConfig = unknown> extends ISandboxLifecycle<TSandboxConfig>, ICommandExecution, IFileSystem, IHealthCheck {
+export interface ISandbox extends ISandboxLifecycle, ICommandExecution, IFileSystem, IHealthCheck {
     /** Provider name (e.g., 'opensandbox') */
     readonly provider: string;
 }

package/dist/interfaces/ISandboxLifecycle.d.ts

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

package/package.json

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