@fastgpt-sdk/sandbox-adapter 0.0.36 → 0.0.38-beta.0

package/dist/index.js

@@ -5,39 +5,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -19141,7 +19162,7 @@ var require_frame = __commonJS((exports, module) => {
   var BUFFER_SIZE = 8 * 1024;
   var buffer = null;
   var bufIdx = BUFFER_SIZE;
-  var randomFillSync = runtimeFeatures.has("crypto") ? __require("node:crypto").randomFillSync : function randomFillSync(buffer2, _offset, _size) {
+  var randomFillSync = runtimeFeatures.has("crypto") ? __require("node:crypto").randomFillSync : function randomFillSync2(buffer2, _offset, _size) {
     for (let i = 0;i < buffer2.length; ++i) {
       buffer2[i] = Math.random() * 255 | 0;
     }
@@ -21085,7 +21106,7 @@ var require_eventsource = __commonJS((exports, module) => {
 
 // node_modules/undici/index.js
 var require_undici = __commonJS((exports, module) => {
-  var __filename = "/Volumes/code/dev/agent-sandbox-adaptor/node_modules/undici/index.js";
+  var __filename = "/Users/sealos/Documents/GitHub/agent-sandbox-adaptor/node_modules/undici/index.js";
   var Client = require_client();
   var Dispatcher = require_dispatcher();
   var Pool = require_pool();
@@ -21208,7 +21229,7 @@ var require_undici = __commonJS((exports, module) => {
     err.stack = stack ? `${stack}
 ${captureLines}` : capture.stack;
   }
-  exports.fetch = function fetch(init, options = undefined) {
+  exports.fetch = function fetch2(init, options = undefined) {
     return fetchImpl(init, options).catch((err) => {
       appendFetchStackTrace(err, __filename);
       throw err;
@@ -45372,6 +45393,12 @@ class BaseSandboxAdapter {
   async renewExpiration(_additionalSeconds) {
     throw new FeatureNotSupportedError("Sandbox expiration renewal not supported by this provider", "renewExpiration", this.provider);
   }
+  async getEndpoint(_selector) {
+    throw new FeatureNotSupportedError("Endpoint resolution not supported by this provider", "getEndpoint", this.provider);
+  }
+  async getProxyTarget(_service = "code-server") {
+    throw new FeatureNotSupportedError("Proxy target resolution not supported by this provider", "getProxyTarget", this.provider);
+  }
   async executeStream(command, handlers, options) {
     const result = await this.execute(command, options);
     if (handlers.onStdout && result.stdout) {
@@ -45608,10 +45635,10 @@ class DevboxApi {
     const result = await res.json();
     return result;
   }
-  async create(name) {
+  async create(req) {
     return this.request(this.url("/api/v1/devbox"), {
       method: "POST",
-      body: JSON.stringify({ name })
+      body: JSON.stringify(req)
     });
   }
   async info(name) {
@@ -45624,6 +45651,11 @@ class DevboxApi {
       method: "POST"
     });
   }
+  async stop(name) {
+    return this.request(this.url(`/api/v1/devbox/${name}/stop`), {
+      method: "POST"
+    });
+  }
   async resume(name) {
     return this.request(this.url(`/api/v1/devbox/${name}/resume`), {
       method: "POST"
@@ -45669,18 +45701,60 @@ class DevboxApi {
   }
 }
 
+// src/adapters/ports.ts
+var OPEN_SANDBOX_EXECD_PORT = 44772;
+var OPEN_SANDBOX_CODE_SERVER_PORT = 8080;
+var SEALOS_DEVBOX_CODE_SERVER_PORT = 1318;
+
+// src/utils/image.ts
+function formatImageSpec(image) {
+  const parts = [image.repository];
+  if (image.tag)
+    parts.push(":", image.tag);
+  if (image.digest)
+    parts.push("@", image.digest);
+  return parts.join("");
+}
+function parseImageSpec(image) {
+  if (!image)
+    return { repository: "" };
+  const atIndex = image.indexOf("@");
+  if (atIndex > -1) {
+    return { repository: image.slice(0, atIndex), digest: image.slice(atIndex + 1) };
+  }
+  const colonIndex = image.indexOf(":");
+  if (colonIndex > -1) {
+    return { repository: image.slice(0, colonIndex), tag: image.slice(colonIndex + 1) };
+  }
+  return { repository: image };
+}
+
+// src/utils/url.ts
+function normalizePathPrefix(path) {
+  if (!path)
+    return "";
+  const normalized = path.startsWith("/") ? path : `/${path}`;
+  return normalized.length > 1 ? normalized.replace(/\/+$/, "") : "";
+}
+function joinUrlPath(url, path) {
+  const normalizedPath = normalizePathPrefix(path);
+  return normalizedPath ? `${url.replace(/\/+$/, "")}${normalizedPath}` : url.replace(/\/+$/, "");
+}
+
 // src/adapters/SealosDevboxAdapter/index.ts
 class SealosDevboxAdapter extends BaseSandboxAdapter {
   config;
+  createConfig;
   provider = "sealosdevbox";
   get rootPath() {
     return "/home/devbox/workspace";
   }
   api;
   _id;
-  constructor(config) {
+  constructor(config, createConfig) {
     super();
     this.config = config;
+    this.createConfig = createConfig;
     this.api = new DevboxApi({ baseUrl: config.baseUrl, token: config.token });
     this._id = config.sandboxId;
     this.polyfillService = new CommandPolyfillService(this);
@@ -45705,6 +45779,26 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
         return "Error";
     }
   }
+  buildCreateRequest() {
+    const spec = this.createConfig ?? {};
+    const env = { ...spec.env ?? {} };
+    if (spec.workingDir && !env.CODEX_GATEWAY_CWD) {
+      env.CODEX_GATEWAY_CWD = spec.workingDir;
+    }
+    return this.removeUndefined({
+      name: this._id,
+      image: spec.image ? formatImageSpec(spec.image) : undefined,
+      env: Object.keys(env).length > 0 ? env : undefined,
+      labels: spec.labels,
+      upstreamID: spec.upstreamID,
+      kubeAccess: spec.kubeAccess,
+      pauseAt: spec.lifecycle?.pauseAt,
+      archiveAfterPauseTime: spec.lifecycle?.archiveAfterPauseTime
+    });
+  }
+  removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+  }
   async getInfo() {
     try {
       const res = await this.api.info(this._id);
@@ -45716,10 +45810,10 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
       this._status = { state: this.StatusAdapt(data), message: res.message };
       return {
         id: data.name,
-        image: { repository: "" },
+        image: parseImageSpec(data.image),
         entrypoint: [],
         status: this._status,
-        createdAt: new Date
+        createdAt: data.creationTimestamp ? new Date(data.creationTimestamp) : new Date
       };
     } catch (error) {
       throw new CommandExecutionError(`Failed to get sandbox info`, "getInfo", error instanceof Error ? error : undefined);
@@ -45757,7 +45851,10 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
   async create() {
     try {
       this._status = { state: "Creating" };
-      await this.api.create(this._id);
+      const res = await this.api.create(this.buildCreateRequest());
+      if (res.code !== 200 && res.code !== 201) {
+        throw new Error(res.message || `Devbox create failed with code ${res.code}`);
+      }
       await this.waitUntilReady();
       await new Promise((resolve) => setTimeout(resolve, 1000));
       this._status = { state: "Running" };
@@ -45768,10 +45865,10 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
   async stop() {
     try {
       this._status = { state: "Stopping" };
-      await this.api.pause(this._id);
+      await this.api.stop(this._id);
       this._status = { state: "Stopped" };
     } catch (error) {
-      throw new CommandExecutionError("Failed to pause sandbox", "pause", error instanceof Error ? error : undefined);
+      throw new CommandExecutionError("Failed to stop sandbox", "stop", error instanceof Error ? error : undefined);
     }
   }
   async start() {
@@ -45813,11 +45910,125 @@ class SealosDevboxAdapter extends BaseSandboxAdapter {
       throw new CommandExecutionError(`Command execution failed: ${error?.message || error?.code}`, command, error instanceof Error ? error : undefined);
     }
   }
+  async getEndpoint(selector) {
+    const port = typeof selector === "number" ? selector : SEALOS_DEVBOX_CODE_SERVER_PORT;
+    const target = await this.getHttpgateTarget(port);
+    if (selector === "code-server") {
+      await this.waitForCodeServerHealthz(target);
+    }
+    const url = new URL(target.origin);
+    return {
+      host: url.host,
+      port: target.port,
+      protocol: url.protocol === "https:" ? "https" : "http",
+      url: joinUrlPath(target.origin, target.basePath)
+    };
+  }
+  async getProxyTarget(service = "code-server") {
+    if (service !== "code-server") {
+      throw new FeatureNotSupportedError(`Proxy service "${service}" is not supported by this provider`, "getProxyTarget", this.provider);
+    }
+    const target = await this.getHttpgateTarget(SEALOS_DEVBOX_CODE_SERVER_PORT);
+    return {
+      service,
+      origin: target.origin,
+      basePath: target.basePath,
+      auth: "code-server",
+      ...target.password ? { password: target.password } : {}
+    };
+  }
+  async waitForCodeServerHealthz(target) {
+    const healthUrl = joinUrlPath(joinUrlPath(target.origin, target.basePath), "/healthz");
+    const timeoutMs = 60000;
+    const intervalMs = 500;
+    const requestTimeoutMs = 3000;
+    const deadline = Date.now() + timeoutMs;
+    let lastResult = "not checked";
+    while (Date.now() < deadline) {
+      try {
+        const res = await fetch(healthUrl, {
+          method: "GET",
+          signal: AbortSignal.timeout(requestTimeoutMs)
+        });
+        if (res.status >= 200 && res.status < 400) {
+          return;
+        }
+        lastResult = `status ${res.status}`;
+      } catch (error) {
+        lastResult = error instanceof Error ? error.message : String(error);
+      }
+      await this.sleep(intervalMs);
+    }
+    throw new ConnectionError(`Devbox code-server health check ${healthUrl} did not become ready within ${timeoutMs}ms. Last result: ${lastResult}`, this.config.baseUrl);
+  }
+  async getHttpgateTarget(port) {
+    const res = await this.api.info(this._id);
+    if (res.code !== 200 || !res.data) {
+      throw new ConnectionError(`Failed to get devbox info: ${res.message}`, this.config.baseUrl);
+    }
+    if (port === SEALOS_DEVBOX_CODE_SERVER_PORT) {
+      const gateway2 = res.data.codeServerGateway;
+      if (!gateway2?.url) {
+        throw new ConnectionError("Devbox info does not include codeServerGateway.url; cannot resolve code-server endpoint", this.config.baseUrl);
+      }
+      const codeServerUrl = new URL(gateway2.url);
+      return {
+        origin: codeServerUrl.origin,
+        basePath: normalizePathPrefix(codeServerUrl.pathname),
+        port: gateway2.port ?? port,
+        password: gateway2.password
+      };
+    }
+    const gatewayUrl = res.data.gateway?.url;
+    if (!gatewayUrl) {
+      throw new ConnectionError("Devbox info does not include gateway.url; cannot derive httpgate endpoint", this.config.baseUrl);
+    }
+    const gateway = new URL(gatewayUrl);
+    const uniqueID = this.getGatewayUniqueID(res.data, gateway);
+    const domain = this.getHttpgateDomain(gateway);
+    return {
+      origin: `${gateway.protocol}//devbox-${uniqueID}-${port}.${domain}`,
+      basePath: "",
+      port
+    };
+  }
+  getGatewayUniqueID(data, gateway) {
+    if (data.gateway?.uniqueID)
+      return data.gateway.uniqueID;
+    const parts = gateway.pathname.split("/").filter(Boolean);
+    const uniqueID = parts[parts.length - 1];
+    if (!uniqueID) {
+      throw new ConnectionError("Devbox gateway.url does not include uniqueID; cannot derive httpgate endpoint", this.config.baseUrl);
+    }
+    return uniqueID;
+  }
+  getHttpgateDomain(gateway) {
+    if (this.config.httpgateDomain) {
+      return this.normalizeHttpgateDomain(this.config.httpgateDomain);
+    }
+    const prefix = "devbox-gateway.";
+    if (!gateway.host.startsWith(prefix)) {
+      throw new ConnectionError(`Cannot derive httpgate domain from gateway host "${gateway.host}"`, this.config.baseUrl);
+    }
+    return gateway.host.slice(prefix.length);
+  }
+  normalizeHttpgateDomain(domain) {
+    const trimmed = domain.trim().replace(/^\.+|\.+$/g, "");
+    if (!trimmed) {
+      throw new ConnectionError("httpgateDomain is empty", this.config.baseUrl);
+    }
+    if (trimmed.includes("://")) {
+      return new URL(trimmed).host;
+    }
+    return trimmed;
+  }
   async ping() {
     try {
       const res = await this.api.info(this._id);
       if (res.code !== 200)
         return false;
+      if (!res.data)
+        return false;
       return res.data.state.phase === "Running" /* Running */;
     } catch {
       return false;
@@ -48069,27 +48280,6 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       message: sdkStatus.message
     };
   }
-  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) {
-      return { repository: image.slice(0, atIndex), digest: image.slice(atIndex + 1) };
-    }
-    const colonIndex = image.indexOf(":");
-    if (colonIndex > -1) {
-      return { repository: image.slice(0, colonIndex), tag: image.slice(colonIndex + 1) };
-    }
-    return { repository: image };
-  }
   convertResourceLimits(resourceLimits) {
     if (!resourceLimits)
       return;
@@ -48204,7 +48394,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
     try {
       this._status = { state: "Creating" };
-      const image = this.convertImageSpec(cfg.image);
+      const image = formatImageSpec(cfg.image);
       const resource = this.convertResourceLimits(cfg.resourceLimits);
       this.sandbox = await Sandbox.create({
         connectionConfig: this._connection,
@@ -48308,7 +48498,18 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
   async close() {
     await this.sandbox.close();
   }
-  async getEndpoint(port) {
+  async getEndpoint(selector) {
+    const port = typeof selector === "number" ? selector : OPEN_SANDBOX_EXECD_PORT;
+    const endpoint = await this.getOpenSandboxEndpoint(port);
+    if (selector === "code-server") {
+      return {
+        ...endpoint,
+        url: joinUrlPath(endpoint.url, `/proxy/${OPEN_SANDBOX_CODE_SERVER_PORT}`)
+      };
+    }
+    return endpoint;
+  }
+  async getOpenSandboxEndpoint(port) {
     const sdkEndpoint = await this.sandbox.getEndpoint(port);
     const raw = sdkEndpoint.endpoint;
     const colonIdx = raw.lastIndexOf(":");
@@ -48327,6 +48528,40 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       url: `https://${raw}`
     };
   }
+  async getProxyTarget(service = "code-server") {
+    if (service !== "code-server") {
+      throw new FeatureNotSupportedError(`Proxy service "${service}" is not supported by this provider`, "getProxyTarget", this.provider);
+    }
+    return {
+      service,
+      origin: await this.getDirectEndpointOrigin(OPEN_SANDBOX_EXECD_PORT),
+      basePath: `/proxy/${OPEN_SANDBOX_CODE_SERVER_PORT}`,
+      auth: "code-server"
+    };
+  }
+  async getDirectEndpointOrigin(port) {
+    if (!this.id) {
+      throw new SandboxStateError("Sandbox not initialized. Call create() or connect() first.", "UnExist", "Running");
+    }
+    const headers = {
+      ...this._connection.headers,
+      Accept: "application/json"
+    };
+    const response = await this._connection.fetch(`${this._connection.getBaseUrl()}/sandboxes/${this.id}/endpoints/${port}?use_server_proxy=false`, { method: "GET", headers });
+    if (!response.ok) {
+      throw new ConnectionError(`OpenSandbox endpoint lookup failed: HTTP ${response.status}`, this.connectionConfig.baseUrl);
+    }
+    const data = await response.json();
+    if (!data.endpoint) {
+      throw new ConnectionError("OpenSandbox returned no endpoint", this.connectionConfig.baseUrl);
+    }
+    let hostPort = data.endpoint.replace(/\/proxy\/\d+\/?$/, "");
+    if (this.connectionConfig.replaceDockerInternalWithLocalhost) {
+      hostPort = hostPort.replace(/^host\.docker\.internal\b/, "localhost");
+    }
+    const url = new URL(/^https?:\/\//.test(hostPort) ? hostPort : `http://${hostPort}`);
+    return url.origin;
+  }
   async getInfo() {
     if (!this._sandbox) {
       return null;
@@ -48335,7 +48570,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
       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,
+        image: typeof info.image === "string" ? parseImageSpec(info.image) : ("uri" in info.image) ? parseImageSpec(info.image.uri) : info.image,
         entrypoint: info.entrypoint,
         metadata: info.metadata,
         status: this.mapStatus(info.status),
@@ -48837,7 +49072,7 @@ function createSandbox(provider, config, createConfig) {
     case "opensandbox":
       return new OpenSandboxAdapter(config, createConfig);
     case "sealosdevbox":
-      return new SealosDevboxAdapter(config);
+      return new SealosDevboxAdapter(config, createConfig);
     case "e2b":
       return new E2BAdapter(config);
     default:

package/dist/interfaces/ISandbox.d.ts

@@ -2,6 +2,7 @@ import type { ICommandExecution } from './ICommandExecution';
 import type { IFileSystem } from './IFileSystem';
 import type { IHealthCheck } from './IHealthCheck';
 import type { ISandboxLifecycle } from './ISandboxLifecycle';
+import type { Endpoint, SandboxEndpointSelector, SandboxProxyService, SandboxProxyTarget } from '../types';
 /**
  * Unified sandbox interface.
  * Composes all sandbox behaviors into a single interface.
@@ -15,4 +16,8 @@ import type { ISandboxLifecycle } from './ISandboxLifecycle';
 export interface ISandbox extends ISandboxLifecycle, ICommandExecution, IFileSystem, IHealthCheck {
     /** Provider name (e.g., 'opensandbox') */
     readonly provider: string;
+    /** Resolve an endpoint exposed by the sandbox provider. */
+    getEndpoint(selector: SandboxEndpointSelector): Promise<Endpoint>;
+    /** Resolve the upstream target used by FastGPT sandbox-proxy. */
+    getProxyTarget(service?: SandboxProxyService): Promise<SandboxProxyTarget>;
 }

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, SandboxId, SandboxInfo, SandboxMetrics, SandboxState, SandboxStatus } from './sandbox';
+export type { Endpoint, ImageSpec, KubeAccessPolicy, LabelSpec, LifecyclePolicy, NetworkPolicy, ResourceLimits, SandboxCreateSpec, SandboxEndpointSelector, SandboxId, SandboxInfo, SandboxMetrics, SandboxProxyService, SandboxProxyTarget, SandboxState, SandboxStatus } from './sandbox';

package/dist/types/sandbox.d.ts

@@ -37,6 +37,18 @@ export interface NetworkPolicy {
     allowEgress?: boolean;
     allowedHosts?: string[];
 }
+export interface LabelSpec {
+    key: string;
+    value: string;
+}
+export interface LifecyclePolicy {
+    pauseAt?: string;
+    archiveAfterPauseTime?: string;
+}
+export interface KubeAccessPolicy {
+    enabled?: boolean;
+    roleTemplate?: 'view' | 'edit' | 'admin';
+}
 /**
  * Information about a sandbox.
  */
@@ -69,3 +81,36 @@ export interface Endpoint {
     protocol: 'http' | 'https';
     url: string;
 }
+/**
+ * App-facing create spec shared by callers that choose a provider at runtime.
+ * Individual adapters should map only the fields their backend actually supports.
+ */
+export interface SandboxCreateSpec {
+    image?: ImageSpec;
+    entrypoint?: string[];
+    timeout?: number;
+    timeoutSeconds?: number | null;
+    resourceLimits?: ResourceLimits;
+    env?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    labels?: LabelSpec[];
+    lifecycle?: LifecyclePolicy;
+    kubeAccess?: KubeAccessPolicy;
+    networkPolicy?: NetworkPolicy;
+    volumes?: unknown[];
+    workingDir?: string;
+    upstreamID?: string;
+    extensions?: Record<string, unknown>;
+    skipHealthCheck?: boolean;
+    readyTimeoutSeconds?: number;
+    healthCheckPollingInterval?: number;
+}
+export type SandboxProxyService = 'code-server';
+export type SandboxEndpointSelector = number | SandboxProxyService;
+export interface SandboxProxyTarget {
+    service: SandboxProxyService;
+    origin: string;
+    basePath: string;
+    auth: 'code-server';
+    password?: string;
+}

package/dist/utils/image.d.ts

@@ -0,0 +1,3 @@
+import type { ImageSpec } from '@/types';
+export declare function formatImageSpec(image: ImageSpec): string;
+export declare function parseImageSpec(image?: string): ImageSpec;

package/dist/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizePathPrefix(path: string): string;
+export declare function joinUrlPath(url: string, path: string): string;

package/package.json

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