@fastgpt-sdk/sandbox-adapter 0.0.15 → 0.0.16

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -54,4 +54,6 @@ export declare abstract class BaseSandboxAdapter implements ISandbox {
     getMetrics(): Promise<SandboxMetrics>;
     protected sleep(ms: number): Promise<void>;
     protected requirePolyfillService(feature: string, message: string): CommandPolyfillService;
+    protected escapeShellArg(arg: string): string;
+    protected buildCommand(command: string, workingDirectory?: string): string[];
 }

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

@@ -1,4 +1,4 @@
-import type { ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo, SandboxMetrics, StreamHandlers } from '@/types';
+import type { Endpoint, ExecuteOptions, ExecuteResult, SandboxId, SandboxInfo, SandboxMetrics, StreamHandlers } from '@/types';
 import { BaseSandboxAdapter } from '../BaseSandboxAdapter';
 import type { OpenSandboxConfigType } from './type';
 export type { OpenSandboxConfigType } from './type';
@@ -44,13 +44,13 @@ export interface OpenSandboxConnectionConfig {
  */
 export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     private connectionConfig;
-    private createConfig;
+    private createConfig?;
     readonly provider: "opensandbox";
     readonly runtime: SandboxRuntimeType;
     private _sandbox?;
     private _connection;
     private _id;
-    constructor(connectionConfig: OpenSandboxConnectionConfig | undefined, createConfig: OpenSandboxConfigType);
+    constructor(connectionConfig?: OpenSandboxConnectionConfig, createConfig?: OpenSandboxConfigType | undefined);
     get id(): SandboxId;
     private get sandbox();
     private createConnectionConfig;
@@ -66,6 +66,23 @@ export declare class OpenSandboxAdapter extends BaseSandboxAdapter {
     start(): Promise<void>;
     stop(): Promise<void>;
     delete(): Promise<void>;
+    /**
+     * Release client-side resources owned by this Sandbox instance.
+     * Does NOT stop or delete the container - the sandbox keeps running.
+     * Use this to disconnect from a sandbox without destroying it.
+     */
+    close(): Promise<void>;
+    /**
+     * Get endpoint information for a specific port exposed by the sandbox.
+     * @param port The port number to get endpoint for
+     * @returns Endpoint with host, port, protocol and url fields
+     */
+    getEndpoint(port: number): Promise<Endpoint>;
+    /**
+     * Convert SDK Endpoint (no-scheme string) to our Endpoint type.
+     * SDK format: "localhost:44772" or "domain/route/.../44772"
+     */
+    private convertSdkEndpoint;
     getInfo(): Promise<SandboxInfo | null>;
     renewExpiration(additionalSeconds: number): Promise<void>;
     execute(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;

package/dist/adapters/index.d.ts

@@ -1,6 +1,10 @@
 import { type SealosDevboxConfig } from './SealosDevboxAdapter';
 import { type OpenSandboxConnectionConfig, type OpenSandboxConfigType } from './OpenSandboxAdapter';
 import { ISandbox } from '@/interfaces';
+export { SealosDevboxAdapter } from './SealosDevboxAdapter';
+export type { SealosDevboxConfig } from './SealosDevboxAdapter';
+export { OpenSandboxAdapter } from './OpenSandboxAdapter';
+export type { OpenSandboxConfigType, OpenSandboxConnectionConfig } from './OpenSandboxAdapter';
 export type SandboxProviderType = 'opensandbox' | 'sealosdevbox';
 /** Maps each provider name to the ISandbox config type it exposes. */
 interface SandboxConfigMap {
@@ -21,5 +25,4 @@ interface SandboxConnectionConfig {
  * @returns Configured sandbox instance
  * @throws Error if provider type is unknown
  */
-export declare function createSandbox<P extends SandboxProviderType>(provider: P, config: SandboxConnectionConfig[P], createConfig: SandboxConfigMap[P]): ISandbox;
-export {};
+export declare function createSandbox<P extends SandboxProviderType>(provider: P, config: SandboxConnectionConfig[P], createConfig?: SandboxConfigMap[P]): ISandbox;

package/dist/index.js

@@ -356,6 +356,8 @@ POLYFILL_EOF`);
     };
   }
   escapePath(path) {
+    if (!path)
+      return ".";
     return path.replace(/"/g, "\\\"");
   }
   parseLsOutput(output, basePath) {
@@ -624,6 +626,16 @@ class BaseSandboxAdapter {
     }
     return this.polyfillService;
   }
+  escapeShellArg(arg) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+  }
+  buildCommand(command, workingDirectory) {
+    if (workingDirectory) {
+      const escapedDir = this.escapeShellArg(workingDirectory);
+      return ["sh", "-lc", `cd ${escapedDir} && ${command}`];
+    }
+    return ["sh", "-lc", command];
+  }
 }
 
 // src/adapters/SealosDevboxAdapter/api.ts
@@ -650,6 +662,9 @@ class DevboxApi {
       headers.set("Content-Type", "application/json");
     }
     const res = await fetch(input, { ...init, headers });
+    if (!res.ok) {
+      throw new Error(res.statusText || res.status.toString());
+    }
     const result = await res.json();
     return result;
   }
@@ -805,7 +820,7 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
       }
       await this.create();
     } catch (error) {
-      throw new ConnectionError("Failed to ensure sandbox running", this.config.baseUrl, error);
+      throw new ConnectionError(`Failed to ensure sandbox running: ${error?.message || error?.code}`, this.config.baseUrl, error);
     }
   }
   async create() {
@@ -848,7 +863,8 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
     }
   }
   async execute(command, options) {
-    const cmd = options?.workingDirectory ? ["sh", "-lc", `cd ${options.workingDirectory} && ${command}`] : ["sh", "-lc", command];
+    const cmd = this.buildCommand(command, options?.workingDirectory);
+    console.log(cmd, 2222);
     try {
       const res = await this.api.exec(this._id, {
         command: cmd,
@@ -879,7 +895,10 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
 }
 
 // src/adapters/OpenSandboxAdapter/index.ts
-import { ConnectionConfig, Sandbox } from "@alibaba-group/opensandbox";
+import {
+  ConnectionConfig,
+  Sandbox
+} from "@alibaba-group/opensandbox";
 class OpenSandboxAdapter extends BaseSandboxAdapter {
   connectionConfig;
   createConfig;
@@ -894,6 +913,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     this.createConfig = createConfig;
     this.runtime = connectionConfig.runtime ?? "docker";
     this._connection = this.createConnectionConfig();
+    this.polyfillService = new CommandPolyfillService(this);
   }
   get id() {
     return this._id;
@@ -1000,18 +1020,22 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     return this.create();
   }
   async create() {
+    if (!this.createConfig) {
+      throw new Error("createConfig is required to create a sandbox. Pass it as the third argument to createSandbox().");
+    }
+    const cfg = this.createConfig;
     try {
       this._status = { state: "Creating" };
-      const image = this.convertImageSpec(this.createConfig.image);
-      const resource = this.convertResourceLimits(this.createConfig.resourceLimits);
+      const image = this.convertImageSpec(cfg.image);
+      const resource = this.convertResourceLimits(cfg.resourceLimits);
       this._sandbox = await Sandbox.create({
         connectionConfig: this._connection,
         image,
-        entrypoint: this.createConfig.entrypoint,
-        timeoutSeconds: this.createConfig.timeout,
+        entrypoint: cfg.entrypoint,
+        timeoutSeconds: cfg.timeout,
         resource,
-        env: this.createConfig.env,
-        metadata: this.createConfig.metadata
+        env: cfg.env,
+        metadata: cfg.metadata
       });
       this._id = this._sandbox.id;
       this._status = { state: "Running" };
@@ -1067,6 +1091,33 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       throw new CommandExecutionError("Failed to delete sandbox", "delete", error instanceof Error ? error : undefined);
     }
   }
+  async close() {
+    if (this._sandbox) {
+      await this._sandbox.close();
+    }
+  }
+  async getEndpoint(port) {
+    const sdkEndpoint = await this.sandbox.getEndpoint(port);
+    return this.convertSdkEndpoint(sdkEndpoint, port);
+  }
+  convertSdkEndpoint(sdkEndpoint, requestedPort) {
+    const raw = sdkEndpoint.endpoint;
+    const colonIdx = raw.lastIndexOf(":");
+    const hasPathBeforeColon = colonIdx !== -1 && raw.slice(0, colonIdx).includes("/");
+    if (colonIdx !== -1 && !hasPathBeforeColon) {
+      const host = raw.slice(0, colonIdx);
+      const parsedPort = parseInt(raw.slice(colonIdx + 1), 10);
+      const port = isNaN(parsedPort) ? requestedPort : parsedPort;
+      const protocol = port === 443 ? "https" : "http";
+      return { host, port, protocol, url: `${protocol}://${raw}` };
+    }
+    return {
+      host: raw,
+      port: requestedPort,
+      protocol: "https",
+      url: `https://${raw}`
+    };
+  }
   async getInfo() {
     if (!this._sandbox)
       return null;
@@ -1212,9 +1263,11 @@ function createSandbox(provider, config, createConfig) {
 export {
   createSandbox,
   TimeoutError,
+  SealosDevboxAdapter,
   SandboxStateError,
   SandboxReadyTimeoutError,
   SandboxException,
+  OpenSandboxAdapter,
   FileOperationError,
   FeatureNotSupportedError,
   ConnectionError,

package/package.json

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