@fastgpt-sdk/sandbox-adapter 0.0.35 → 0.0.37

package/dist/index.cjs

@@ -4,39 +4,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);
@@ -19139,7 +19160,7 @@ var require_frame = __commonJS((exports2, module2) => {
   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;
     }
@@ -21083,7 +21104,7 @@ var require_eventsource = __commonJS((exports2, module2) => {
 
 // node_modules/undici/index.js
 var require_undici = __commonJS((exports2, module2) => {
-  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();
@@ -21206,7 +21227,7 @@ var require_undici = __commonJS((exports2, module2) => {
     err.stack = stack ? `${stack}
 ${captureLines}` : capture.stack;
   }
-  module2.exports.fetch = function fetch(init, options = undefined) {
+  module2.exports.fetch = function fetch2(init, options = undefined) {
     return fetchImpl(init, options).catch((err) => {
       appendFetchStackTrace(err, __filename);
       throw err;
@@ -45023,13 +45044,34 @@ class CommandPolyfillService {
   constructor(executor) {
     this.executor = executor;
   }
+  static READ_CHUNK_SIZE = 256 * 1024;
   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);
+      const size = await this.statSize(path);
+      if (size === undefined) {
+        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);
+      }
+      if (size === 0)
+        return new Uint8Array;
+      const chunks = [];
+      let totalLength = 0;
+      for (let offset = 0;offset < size; offset += CommandPolyfillService.READ_CHUNK_SIZE) {
+        const end = Math.min(offset + CommandPolyfillService.READ_CHUNK_SIZE, size);
+        const chunk = await this.readFileRange(path, offset, end);
+        chunks.push(chunk);
+        totalLength += chunk.length;
       }
-      return base64ToBytes(result.stdout);
+      const combined = new Uint8Array(totalLength);
+      let writeOffset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, writeOffset);
+        writeOffset += chunk.length;
+      }
+      return combined;
     } catch (error) {
       if (error instanceof FileOperationError) {
         throw error;
@@ -45040,9 +45082,18 @@ class CommandPolyfillService {
       throw error;
     }
   }
+  async statSize(path) {
+    const result = await this.executor.execute(`stat -c '%s' "${this.escapePath(path)}" 2>/dev/null || stat -f '%z' "${this.escapePath(path)}" 2>/dev/null || echo STAT_FAILED`);
+    const stdout = result.stdout.trim();
+    if (!stdout || stdout.includes("STAT_FAILED"))
+      return;
+    const parsed = Number.parseInt(stdout, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+  }
   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 escaped = this.escapePath(path);
+    const tailPos = start + 1;
+    const cmd = end !== undefined ? `tail -c +${tailPos} "${escaped}" | head -c ${end - start} | base64 -w 0` : `tail -c +${tailPos} "${escaped}" | base64 -w 0`;
     const result = await this.executor.execute(cmd);
     if (result.exitCode !== 0) {
       throw this.createFileError(path, result.stderr);
@@ -45050,10 +45101,25 @@ class CommandPolyfillService {
     return base64ToBytes(result.stdout);
   }
   async writeFile(path, data) {
+    await this.appendBytes(path, data, { truncate: true });
+    return data.length;
+  }
+  async appendBytes(path, data, options) {
+    if (options?.truncate) {
+      await this.createParentDirectory(path);
+    }
+    if (data.length === 0) {
+      if (options?.truncate) {
+        const result = await this.executor.execute(`: > "${this.escapePath(path)}"`);
+        if (result.exitCode !== 0) {
+          throw this.createFileError(path, result.stderr);
+        }
+      }
+      return;
+    }
     const base64 = bytesToBase64(data);
     const chunkSize = 1024;
-    await this.createParentDirectory(path);
-    let first = true;
+    let first = Boolean(options?.truncate);
     for (let i = 0;i < base64.length; i += chunkSize) {
       const chunk = base64.slice(i, i + chunkSize);
       const redirect = first ? ">" : ">>";
@@ -45063,7 +45129,6 @@ class CommandPolyfillService {
       }
       first = false;
     }
-    return data.length;
   }
   async writeTextFile(path, content) {
     await this.createParentDirectory(path);
@@ -45344,6 +45409,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) {
@@ -45406,23 +45477,7 @@ class BaseSandboxAdapter {
           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);
+          bytesWritten = await this.writeStreamToFile(polyfillService, entry.path, entry.data);
         }
         results.push({ path: entry.path, bytesWritten, error: null });
       } catch (error) {
@@ -45497,23 +45552,36 @@ class BaseSandboxAdapter {
     }
   }
   async writeFileStream(path, stream) {
+    const polyfillService = this.requirePolyfillService("writeFileStream", "File stream write not supported by this provider");
+    await this.writeStreamToFile(polyfillService, this.normalizePath(path), stream);
+  }
+  async writeStreamToFile(polyfillService, path, stream) {
+    const tmpPath = `${path}.tmp.${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
     const reader = stream.getReader();
-    const chunks = [];
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
+    let totalBytes = 0;
+    let first = true;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (!value || value.length === 0)
+          continue;
+        await polyfillService.appendBytes(tmpPath, value, first ? { truncate: true } : undefined);
+        totalBytes += value.length;
+        first = false;
       }
-      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;
+      if (first) {
+        await polyfillService.appendBytes(tmpPath, new Uint8Array, { truncate: true });
+      }
+      await polyfillService.moveFiles([{ source: tmpPath, destination: path }]);
+    } catch (error) {
+      await polyfillService.deleteFiles([tmpPath]).catch(() => {});
+      throw error;
+    } finally {
+      reader.releaseLock();
     }
-    await this.writeFiles([{ path, data: combined }]);
+    return totalBytes;
   }
   async getFileInfo(paths) {
     const polyfillService = this.requirePolyfillService("getFileInfo", "File info not supported by this provider");
@@ -45583,10 +45651,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) {
@@ -45644,18 +45712,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);
@@ -45680,6 +45790,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);
@@ -45691,10 +45821,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);
@@ -45732,7 +45862,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" };
@@ -45788,11 +45921,98 @@ 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);
+    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 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;
@@ -47384,7 +47604,7 @@ function createNodeFetch() {
   const nodeFetch = async (input, init) => {
     dispatcherPromise ??= (async () => {
       try {
-        const mod = await Promise.resolve().then(() => __toESM(require_undici()));
+        const mod = await Promise.resolve().then(() => __toESM(require_undici(), 1));
         const Agent = mod.Agent;
         if (!Agent) {
           return;
@@ -47909,7 +48129,79 @@ var Sandbox = class _Sandbox {
   }
 };
 
+// src/utils/outputBuffer.ts
+class BoundedOutputBuffer {
+  maxBytes;
+  chunks = [];
+  currentBytes = 0;
+  _totalBytes = 0;
+  _truncated = false;
+  separatorBuf;
+  constructor(maxBytes, separator) {
+    this.maxBytes = maxBytes;
+    if (!(maxBytes > 0)) {
+      throw new Error(`BoundedOutputBuffer: maxBytes must be > 0 (got ${maxBytes})`);
+    }
+    if (separator) {
+      this.separatorBuf = Buffer.from(separator, "utf8");
+    }
+  }
+  append(text) {
+    if (!text)
+      return;
+    const needsSep = this.separatorBuf && this.chunks.length > 0;
+    const textBuf = Buffer.from(text, "utf8");
+    const sepLen = needsSep ? this.separatorBuf.length : 0;
+    this._totalBytes += textBuf.length + sepLen;
+    if (textBuf.length + sepLen > this.maxBytes) {
+      this._truncated = true;
+      const keep = Math.min(textBuf.length, this.maxBytes);
+      this.chunks = [
+        keep < textBuf.length ? Buffer.from(textBuf.subarray(textBuf.length - keep)) : textBuf
+      ];
+      this.currentBytes = keep;
+      return;
+    }
+    const chunk = needsSep ? Buffer.concat([this.separatorBuf, textBuf]) : textBuf;
+    this.chunks.push(chunk);
+    this.currentBytes += chunk.length;
+    if (this.currentBytes <= this.maxBytes)
+      return;
+    this._truncated = true;
+    while (this.chunks.length > 1 && this.currentBytes - this.chunks[0].length >= this.maxBytes) {
+      this.currentBytes -= this.chunks[0].length;
+      this.chunks.shift();
+    }
+    if (this.currentBytes > this.maxBytes && this.chunks.length > 0) {
+      const overflow = this.currentBytes - this.maxBytes;
+      this.chunks[0] = this.chunks[0].subarray(overflow);
+      this.currentBytes -= overflow;
+    }
+    if (this.separatorBuf && this.chunks.length > 0) {
+      const first = this.chunks[0];
+      const sep = this.separatorBuf;
+      if (first.subarray(0, sep.length).equals(sep)) {
+        this.chunks[0] = first.subarray(sep.length);
+        this.currentBytes -= sep.length;
+      }
+    }
+  }
+  get totalBytes() {
+    return this._totalBytes;
+  }
+  get truncated() {
+    return this._truncated;
+  }
+  toString() {
+    if (this.chunks.length === 0)
+      return "";
+    return Buffer.concat(this.chunks, this.currentBytes).toString("utf8");
+  }
+}
+
 // src/adapters/OpenSandboxAdapter/index.ts
+var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+
 class OpenSandboxAdapter extends BaseSandboxAdapter {
   connectionConfig;
   createConfig;
@@ -47972,27 +48264,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;
@@ -48107,7 +48378,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,
@@ -48211,7 +48482,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(":");
@@ -48230,6 +48512,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;
@@ -48238,7 +48554,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),
@@ -48293,21 +48609,30 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     return results;
   }
   async execute(command, options) {
+    const maxBytes = options?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const stdoutBuf = new BoundedOutputBuffer(maxBytes, `
+`);
+    const stderrBuf = new BoundedOutputBuffer(maxBytes, `
+`);
     try {
       const execution = await this.sandbox.commands.run(command, {
         workingDirectory: this.normalizePath(options?.workingDirectory),
         background: options?.background
+      }, {
+        onStdout: (msg) => {
+          stdoutBuf.append(msg.text);
+        },
+        onStderr: (msg) => {
+          stderrBuf.append(msg.text);
+        }
       });
-      const stdout = execution.logs.stdout.map((msg) => msg.text).join(`
-`);
-      const stderr = execution.logs.stderr.map((msg) => msg.text).join(`
-`);
       const exitCode = this.extractExitCode(execution);
-      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 };
+      return {
+        stdout: stdoutBuf.toString(),
+        stderr: stderrBuf.toString(),
+        exitCode,
+        truncated: stdoutBuf.truncated || stderrBuf.truncated
+      };
     } catch (error) {
       if (error instanceof SandboxStateError)
         throw error;
@@ -48315,10 +48640,26 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
     }
   }
   async executeStream(command, handlers, options) {
+    const wantsComplete = Boolean(handlers.onComplete);
+    const maxBytes = options?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const stdoutBuf = wantsComplete ? new BoundedOutputBuffer(maxBytes, `
+`) : undefined;
+    const stderrBuf = wantsComplete ? new BoundedOutputBuffer(maxBytes, `
+`) : undefined;
     try {
       const sdkHandlers = {
-        ...handlers.onStderr ? { onStderr: handlers.onStderr } : {},
-        ...handlers.onStdout ? { onStdout: handlers.onStdout } : {},
+        ...handlers.onStdout || wantsComplete ? {
+          onStdout: async (msg) => {
+            stdoutBuf?.append(msg.text);
+            await handlers.onStdout?.(msg);
+          }
+        } : {},
+        ...handlers.onStderr || wantsComplete ? {
+          onStderr: async (msg) => {
+            stderrBuf?.append(msg.text);
+            await handlers.onStderr?.(msg);
+          }
+        } : {},
         ...handlers.onError ? {
           onError: async (err) => {
             const error = new Error(err.value || err.name || "Execution error");
@@ -48335,17 +48676,14 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
         workingDirectory: this.normalizePath(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(`
-`);
+      if (wantsComplete) {
         const exitCode = this.extractExitCode(execution);
-        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 });
+        await handlers.onComplete({
+          stdout: stdoutBuf.toString(),
+          stderr: stderrBuf.toString(),
+          exitCode,
+          truncated: stdoutBuf.truncated || stderrBuf.truncated
+        });
       }
     } catch (error) {
       throw new CommandExecutionError(`Streaming command execution failed: ${command}`, command, error instanceof Error ? error : undefined);
@@ -48398,7 +48736,7 @@ class OpenSandboxAdapter extends BaseSandboxAdapter {
 }
 
 // src/adapters/E2BAdapter/index.ts
-var import_code_interpreter = __toESM(require_dist3());
+var import_code_interpreter = __toESM(require_dist3(), 1);
 class E2BAdapter extends BaseSandboxAdapter {
   config;
   provider = "e2b";
@@ -48718,7 +49056,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: