@fastgpt-sdk/sandbox-adapter 0.0.35 → 0.0.36

package/dist/adapters/BaseSandboxAdapter.d.ts

@@ -61,6 +61,12 @@ export declare abstract class BaseSandboxAdapter implements ISandbox {
     listDirectory(path: string): Promise<DirectoryEntry[]>;
     readFileStream(path: string): AsyncIterable<Uint8Array>;
     writeFileStream(path: string, stream: ReadableStream<Uint8Array>): Promise<void>;
+    /**
+     * Stream a ReadableStream into a file via a temporary file that is
+     * atomically renamed on success. If the stream fails mid-write, the
+     * original file is left untouched and the temp file is cleaned up.
+     */
+    private writeStreamToFile;
     getFileInfo(paths: string[]): Promise<Map<string, FileInfo>>;
     setPermissions(entries: PermissionEntry[]): Promise<void>;
     search(pattern: string, path?: string): Promise<SearchResult[]>;

package/dist/index.cjs

@@ -45023,13 +45023,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 +45061,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 +45080,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 +45108,6 @@ class CommandPolyfillService {
       }
       first = false;
     }
-    return data.length;
   }
   async writeTextFile(path, content) {
     await this.createParentDirectory(path);
@@ -45406,23 +45450,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 +45525,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");
@@ -47909,7 +47950,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;
@@ -48293,21 +48406,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 +48437,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 +48473,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);

package/dist/index.js

@@ -45007,13 +45007,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;
@@ -45024,9 +45045,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);
@@ -45034,10 +45064,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 ? ">" : ">>";
@@ -45047,7 +45092,6 @@ class CommandPolyfillService {
       }
       first = false;
     }
-    return data.length;
   }
   async writeTextFile(path, content) {
     await this.createParentDirectory(path);
@@ -45390,23 +45434,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) {
@@ -45481,23 +45509,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");
@@ -47893,7 +47934,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;
@@ -48277,21 +48390,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;
@@ -48299,10 +48421,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");
@@ -48319,17 +48457,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);

package/dist/polyfill/CommandPolyfillService.d.ts

@@ -13,12 +13,33 @@ export declare class CommandPolyfillService {
     private readonly executor;
     constructor(executor: ICommandExecution);
     /**
-     * Read a file via base64 encoding.
-     * Uses: cat <file> | base64
+     * Chunk size used when reading files through command execution. Each chunk
+     * produces a base64-encoded stdout of roughly `READ_CHUNK_SIZE * 4 / 3`
+     * bytes, which must fit within the executor's stdout byte cap (default
+     * 1 MiB) with room to spare.
+     */
+    private static readonly READ_CHUNK_SIZE;
+    /**
+     * Read a file in chunks via `dd | base64`. Uses `stat` to discover the file
+     * size, then issues range reads so that no single command's stdout exceeds
+     * the executor's bounded output limit.
+     *
+     * Falls back to a single `cat | base64` read when `stat` fails (e.g. when
+     * the sandbox lacks GNU stat). That fallback is bounded by the caller's
+     * `maxOutputBytes`, so very large files require stat-based chunking.
      */
     readFile(path: string): Promise<Uint8Array>;
     /**
-     * Read a portion of a file via dd + base64.
+     * Return the file size in bytes, or undefined if stat fails (e.g. the file
+     * does not exist or stat is unavailable).
+     */
+    private statSize;
+    /**
+     * Read a portion of a file via `tail -c +N | head -c M | base64`.
+     *
+     * `tail -c +N` emits bytes starting at position N (1-indexed). `head -c M`
+     * caps the length. Both are POSIX-ish and avoid the `dd bs=1` one-syscall-
+     * per-byte trap that made the old implementation unusable for large reads.
      */
     readFileRange(path: string, start: number, end?: number): Promise<Uint8Array>;
     /**
@@ -26,6 +47,17 @@ export declare class CommandPolyfillService {
      * Uses: echo <base64> | base64 -d > <file>
      */
     writeFile(path: string, data: Uint8Array): Promise<number>;
+    /**
+     * Append `data` to `path`, chunking the base64 payload to stay under the
+     * shell command line length limit. Set `truncate` to rewrite the file
+     * from scratch on the first append.
+     *
+     * Parent directory creation runs once when `truncate` is set, so streaming
+     * writes pay the mkdir cost only on the first chunk.
+     */
+    appendBytes(path: string, data: Uint8Array, options?: {
+        truncate?: boolean;
+    }): Promise<void>;
     /**
      * Write a text file directly.
      */

package/dist/types/execution.d.ts

@@ -12,6 +12,16 @@ export interface ExecuteOptions {
     env?: Record<string, string>;
     /** Abort signal for cancellation */
     signal?: AbortSignal;
+    /**
+     * Maximum number of bytes to retain in stdout / stderr for the returned
+     * {@link ExecuteResult}. Output beyond this limit is dropped (oldest first)
+     * and `truncated` is set to true. Streaming handlers (`onStdout` / `onStderr`)
+     * still receive every chunk regardless of this limit.
+     *
+     * Defaults to 1 MiB per stream. Set a larger value for commands whose full
+     * output you need, bearing in mind the memory cost.
+     */
+    maxOutputBytes?: number;
 }
 /**
  * Result of command execution.

package/dist/utils/outputBuffer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bounded, append-only text buffer that keeps only the tail when the total
+ * byte count exceeds `maxBytes`. The head is dropped first, because for
+ * command output the tail is almost always the most useful part (error
+ * messages, summaries, stack traces, final lines).
+ *
+ * Chunks are stored as UTF-8 `Buffer`s so byte counting is O(1) per chunk
+ * and slicing is exact. Decoding only happens in {@link toString}, which
+ * gracefully handles any broken leading multi-byte sequence created by a
+ * mid-character slice.
+ *
+ * Memory is O(maxBytes) regardless of how much data is appended over the
+ * lifetime of the buffer.
+ */
+export declare class BoundedOutputBuffer {
+    private readonly maxBytes;
+    private chunks;
+    private currentBytes;
+    private _totalBytes;
+    private _truncated;
+    private readonly separatorBuf;
+    /**
+     * @param maxBytes  Maximum retained bytes.
+     * @param separator Optional string inserted between consecutive appends
+     *                  (e.g. `'\n'` to replicate the old `join('\n')` behaviour).
+     */
+    constructor(maxBytes: number, separator?: string);
+    append(text: string): void;
+    /** Total bytes appended over the buffer's lifetime (not just the bytes currently stored). */
+    get totalBytes(): number;
+    /** True once any data has been dropped. */
+    get truncated(): boolean;
+    toString(): string;
+}

package/package.json

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