@fastgpt-sdk/sandbox-adapter 0.0.34 → 0.0.36

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.34",
+  "version": "0.0.36",
   "description": "Unified abstraction layer for cloud sandbox providers with adapter pattern and feature polyfilling",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -48,6 +48,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@alibaba-group/opensandbox": "^0.1.5",
     "@e2b/code-interpreter": "^2.3.3"
   },
   "devDependencies": {
@@ -71,7 +72,7 @@
       "prettier --check"
     ],
     "!(.claude)/**/*.{js,cjs,mjs,ts,tsx}": [
-      "eslint --max-warnings=0 --no-warn-ignored"
+      "eslint --max-warnings=0"
     ]
   }
 }