@voidrun/sdk 0.0.1

package/dist/FS.d.ts

@@ -0,0 +1,193 @@
+import { Configuration, ExecResponse } from "./api-client/index";
+import { FolderSizeResponse, StatFileResponse } from "./types";
+export declare class FS {
+    private readonly sandboxId;
+    private readonly config;
+    private readonly fsApi;
+    constructor(sandboxId: string, config: Configuration);
+    listFiles(path: string): Promise<import("./api-client/index").ListFiles200Response>;
+    /**
+     * Download a file and return the full response (non-streaming)
+     */
+    downloadFile(path: string): Promise<Buffer<ArrayBuffer>>;
+    /**
+     * Download a file as a streaming ReadableStream
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * @param path - Path to the file to download
+     * @returns A ReadableStream that can be consumed progressively
+     *
+     * @example
+     * ```ts
+     * const stream = await fs.downloadFileStream('/path/to/file.txt');
+     * const reader = stream.getReader();
+     * while (true) {
+     *   const { done, value } = await reader.read();
+     *   if (done) break;
+     *   // Process chunk: value is a Uint8Array
+     * }
+     * ```
+     */
+    downloadFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Upload a file (non-streaming, accepts string content)
+     * For streaming support, use uploadFileStream() or uploadFileFromSource()
+     */
+    uploadFile(path: string, content: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    /**
+     * Upload a file with true streaming support (ReadableStream)
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * This method streams data directly without buffering the entire file in memory,
+     * making it suitable for large files.
+     *
+     * @param path - Destination path for the file
+     * @param stream - ReadableStream to upload
+     * @param contentType - Optional MIME type (defaults to 'application/octet-stream')
+     * @returns Upload response
+     *
+     * @example
+     * ```ts
+     * // Create a streaming source
+     * const stream = new ReadableStream({
+     *   start(controller) {
+     *     // Enqueue chunks as they become available
+     *     controller.enqueue(new Uint8Array([1, 2, 3]));
+     *     controller.close();
+     *   }
+     * });
+     * await fs.uploadFileStream('/path/to/file.txt', stream);
+     *
+     * // From a File.stream() (browser)
+     * const fileInput = document.querySelector('input[type="file"]');
+     * const fileStream = fileInput.files[0].stream();
+     * await fs.uploadFileStream('/path/to/file.txt', fileStream);
+     * ```
+     */
+    uploadFileStream(path: string, stream: ReadableStream<Uint8Array>, contentType?: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    /**
+     * Upload a file from a local file path (Node.js, Deno, Bun, Serverless)
+     * Streams the file directly without loading it into memory, suitable for large files.
+     *
+     * Supported runtimes:
+     * - Node.js: Uses fs.createReadStream()
+     * - Deno: Uses Deno.open().readable
+     * - Bun: Uses Bun.file().stream()
+     * - Serverless (Node.js-based): Works with files in /tmp directory
+     *
+     * Serverless limitations:
+     * - AWS Lambda: Only /tmp directory is writable (512 MB default, up to 10 GB)
+     * - Vercel Functions: Only /tmp directory is writable
+     * - Cloudflare Workers: Not supported (no file system access)
+     * - Edge runtimes: Not supported (no file system access)
+     *
+     * Note: In serverless environments, files must be in /tmp or the function
+     * will fail with permission errors. Files in /tmp are ephemeral and only
+     * available during the function execution.
+     *
+     * @param remotePath - Destination path on the remote sandbox
+     * @param localPath - Local file system path to the file to upload
+     * @param contentType - Optional MIME type (defaults to 'application/octet-stream')
+     * @returns Upload response
+     *
+     * @throws Error if not running in a supported runtime (Node.js, Deno, or Bun)
+     * @throws Error if file is not found or not accessible
+     *
+     * @example
+     * ```ts
+     * // Upload a large file from local filesystem (works in Node.js, Deno, Bun)
+     * await fs.uploadFileFromPath('/remote/path/to/file.txt', './local/file.txt');
+     *
+     * // Upload with specific content type
+     * await fs.uploadFileFromPath('/remote/image.png', './local/image.png', 'image/png');
+     *
+     * // Serverless example (AWS Lambda / Vercel) - file must be in /tmp
+     * await fs.uploadFileFromPath('/remote/data.json', '/tmp/data.json');
+     * ```
+     */
+    uploadFileFromPath(remotePath: string, localPath: string, contentType?: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    /**
+     * Upload a file from various source types (convenience method)
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * Note: For large files, prefer uploadFileStream() with a ReadableStream
+     * to avoid loading the entire file into memory.
+     *
+     * @param path - Destination path for the file
+     * @param source - Source data: File, Blob, ArrayBuffer, Uint8Array, or string
+     * @param contentType - Optional MIME type
+     * @returns Upload response
+     *
+     * @example
+     * ```ts
+     * // From a File (browser)
+     * const fileInput = document.querySelector('input[type="file"]');
+     * await fs.uploadFile('/path/to/file.txt', fileInput.files[0]);
+     *
+     * // From a Blob
+     * const blob = new Blob(['content']);
+     * await fs.uploadFile('/path/to/file.txt', blob);
+     *
+     * // From a Uint8Array
+     * const data = new Uint8Array([1, 2, 3]);
+     * await fs.uploadFile('/path/to/file.txt', data);
+     *
+     * // From a string
+     * await fs.uploadFile('/path/to/file.txt', 'content');
+     * ```
+     */
+    uploadFileFromSource(path: string, source: File | Blob | ArrayBuffer | Uint8Array | string, contentType?: string): Promise<{
+        status: string;
+        message: string;
+    }>;
+    deleteFile(path: string): Promise<ExecResponse>;
+    createDirectory(path: string): Promise<ExecResponse>;
+    createFile(path: string): Promise<ExecResponse>;
+    moveFile(from: string, to: string): Promise<ExecResponse>;
+    copyFile(from: string, to: string): Promise<ExecResponse>;
+    changePermissions(path: string, mode: string): Promise<ExecResponse>;
+    compressFile(path: string, format?: 'tar' | 'tar.gz' | 'tar.bz2' | 'zip'): Promise<{
+        status?: string;
+        message?: string;
+        data?: import("./api-client/index").ExecResponseData;
+        archivePath: string;
+    }>;
+    statFile(path: string): Promise<{
+        status?: string;
+        message?: string;
+        data?: import("./api-client/index").ExecResponseData;
+        info: StatFileResponse;
+    }>;
+    searchFiles(path: string, pattern?: string): Promise<{
+        status?: string;
+        message?: string;
+        data?: import("./api-client/index").ExecResponseData;
+        paths: string[];
+    }>;
+    headTail(path: string, options?: {
+        lines?: number;
+        head?: boolean;
+    }): Promise<{
+        status?: string;
+        message?: string;
+        data?: import("./api-client/index").ExecResponseData;
+        content: string[];
+    }>;
+    extractArchive(archivePath: string, destPath?: string): Promise<ExecResponse>;
+    folderSize(path: string): Promise<{
+        status?: string;
+        message?: string;
+        data?: import("./api-client/index").ExecResponseData;
+        info: FolderSizeResponse;
+    }>;
+}
+//# sourceMappingURL=FS.d.ts.map

package/dist/FS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FS.d.ts","sourceRoot":"","sources":["../src/FS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAiB,MAAM,oBAAoB,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AA6B/D,qBAAa,EAAE;IAGC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFvE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;gBAET,SAAS,EAAE,MAAM,EAAmB,MAAM,EAAE,aAAa;IAIhF,SAAS,CAAC,IAAI,EAAE,MAAM;IAW5B;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM;IAW/B;;;;;;;;;;;;;;;;;OAiBG;IACG,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IAiB3E;;;OAGG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;IAI9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,gBAAgB,CAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,WAAW,GAAE,MAAmC;;;;IAsCpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACG,kBAAkB,CACpB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,MAAmC;;;;IAiFpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,oBAAoB,CACtB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,EACvD,WAAW,CAAC,EAAE,MAAM;;;;IA4ClB,UAAU,CAAC,IAAI,EAAE,MAAM;IAOvB,eAAe,CAAC,IAAI,EAAE,MAAM;IAO5B,UAAU,CAAC,IAAI,EAAE,MAAM;IAOvB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAQjC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAQjC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAQ5C,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAgB;;;;;;IAkClF,QAAQ,CAAC,IAAI,EAAE,MAAM;;;;;;IAkBrB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAY;;;;;;IAmB/C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE;;;;;;IAwBnE,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAQrD,UAAU,CAAC,IAAI,EAAE,MAAM;;;;;;CAyBhC"}

package/dist/FS.js

@@ -0,0 +1,488 @@
+import { FileSystemApi } from "./api-client/index";
+import { wrapRequest } from "./utils/runtime";
+/**
+ * Detect the JavaScript runtime environment
+ */
+function detectRuntime() {
+    const globalThisAny = globalThis;
+    // Deno
+    if (typeof globalThisAny.Deno !== 'undefined' && globalThisAny.Deno?.version) {
+        return 'deno';
+    }
+    // Bun
+    if (typeof globalThisAny.Bun !== 'undefined') {
+        return 'bun';
+    }
+    // Node.js
+    if (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null) {
+        return 'node';
+    }
+    return 'unknown';
+}
+export class FS {
+    sandboxId;
+    config;
+    fsApi;
+    constructor(sandboxId, config) {
+        this.sandboxId = sandboxId;
+        this.config = config;
+        this.fsApi = new FileSystemApi(config);
+    }
+    async listFiles(path) {
+        // Use raw API to handle non-standard response format
+        const result = await wrapRequest(this.fsApi.listFiles({
+            id: this.sandboxId,
+            path
+        }));
+        return result;
+    }
+    /**
+     * Download a file and return the full response (non-streaming)
+     */
+    async downloadFile(path) {
+        const response = await wrapRequest(this.fsApi.downloadFile({
+            id: this.sandboxId,
+            path
+        }));
+        // save blob to file must be compatible with all platforms
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        return buffer;
+    }
+    /**
+     * Download a file as a streaming ReadableStream
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * @param path - Path to the file to download
+     * @returns A ReadableStream that can be consumed progressively
+     *
+     * @example
+     * ```ts
+     * const stream = await fs.downloadFileStream('/path/to/file.txt');
+     * const reader = stream.getReader();
+     * while (true) {
+     *   const { done, value } = await reader.read();
+     *   if (done) break;
+     *   // Process chunk: value is a Uint8Array
+     * }
+     * ```
+     */
+    async downloadFileStream(path) {
+        const apiResponse = await this.fsApi.downloadFileRaw({
+            id: this.sandboxId,
+            path
+        });
+        // Access the raw Response from BlobApiResponse
+        const response = apiResponse.raw;
+        // Response.body is a ReadableStream in all modern runtimes
+        if (!response.body) {
+            throw new Error('Response body is null');
+        }
+        return response.body;
+    }
+    /**
+     * Upload a file (non-streaming, accepts string content)
+     * For streaming support, use uploadFileStream() or uploadFileFromSource()
+     */
+    async uploadFile(path, content) {
+        return this.uploadFileFromSource(path, content);
+    }
+    /**
+     * Upload a file with true streaming support (ReadableStream)
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * This method streams data directly without buffering the entire file in memory,
+     * making it suitable for large files.
+     *
+     * @param path - Destination path for the file
+     * @param stream - ReadableStream to upload
+     * @param contentType - Optional MIME type (defaults to 'application/octet-stream')
+     * @returns Upload response
+     *
+     * @example
+     * ```ts
+     * // Create a streaming source
+     * const stream = new ReadableStream({
+     *   start(controller) {
+     *     // Enqueue chunks as they become available
+     *     controller.enqueue(new Uint8Array([1, 2, 3]));
+     *     controller.close();
+     *   }
+     * });
+     * await fs.uploadFileStream('/path/to/file.txt', stream);
+     *
+     * // From a File.stream() (browser)
+     * const fileInput = document.querySelector('input[type="file"]');
+     * const fileStream = fileInput.files[0].stream();
+     * await fs.uploadFileStream('/path/to/file.txt', fileStream);
+     * ```
+     */
+    async uploadFileStream(path, stream, contentType = 'application/octet-stream') {
+        // Use uploadFileRaw with initOverrides to pass the ReadableStream directly
+        // This enables true streaming without buffering
+        const response = await this.fsApi.uploadFileRaw({
+            id: this.sandboxId,
+            path,
+            body: new Blob([]) // Dummy blob to satisfy type requirement
+        }, async (requestContext) => {
+            return {
+                ...requestContext.init,
+                body: stream, // Override with the actual stream
+                // @ts-ignore - duplex is required for streaming in Node.js fetch
+                duplex: 'half', // Required for Node.js fetch API with streams
+                headers: {
+                    ...requestContext.init.headers,
+                    'Content-Type': contentType
+                }
+            };
+        });
+        // Extract the raw Response object and handle text response
+        const rawResponse = response.raw;
+        if (!rawResponse.ok) {
+            const errorText = await rawResponse.text();
+            throw new Error(`Upload stream failed: ${errorText}`);
+        }
+        const responseText = await rawResponse.text();
+        return {
+            status: 'success',
+            message: responseText || 'File uploaded successfully'
+        };
+    }
+    /**
+     * Upload a file from a local file path (Node.js, Deno, Bun, Serverless)
+     * Streams the file directly without loading it into memory, suitable for large files.
+     *
+     * Supported runtimes:
+     * - Node.js: Uses fs.createReadStream()
+     * - Deno: Uses Deno.open().readable
+     * - Bun: Uses Bun.file().stream()
+     * - Serverless (Node.js-based): Works with files in /tmp directory
+     *
+     * Serverless limitations:
+     * - AWS Lambda: Only /tmp directory is writable (512 MB default, up to 10 GB)
+     * - Vercel Functions: Only /tmp directory is writable
+     * - Cloudflare Workers: Not supported (no file system access)
+     * - Edge runtimes: Not supported (no file system access)
+     *
+     * Note: In serverless environments, files must be in /tmp or the function
+     * will fail with permission errors. Files in /tmp are ephemeral and only
+     * available during the function execution.
+     *
+     * @param remotePath - Destination path on the remote sandbox
+     * @param localPath - Local file system path to the file to upload
+     * @param contentType - Optional MIME type (defaults to 'application/octet-stream')
+     * @returns Upload response
+     *
+     * @throws Error if not running in a supported runtime (Node.js, Deno, or Bun)
+     * @throws Error if file is not found or not accessible
+     *
+     * @example
+     * ```ts
+     * // Upload a large file from local filesystem (works in Node.js, Deno, Bun)
+     * await fs.uploadFileFromPath('/remote/path/to/file.txt', './local/file.txt');
+     *
+     * // Upload with specific content type
+     * await fs.uploadFileFromPath('/remote/image.png', './local/image.png', 'image/png');
+     *
+     * // Serverless example (AWS Lambda / Vercel) - file must be in /tmp
+     * await fs.uploadFileFromPath('/remote/data.json', '/tmp/data.json');
+     * ```
+     */
+    async uploadFileFromPath(remotePath, localPath, contentType = 'application/octet-stream') {
+        const runtime = detectRuntime();
+        let webStream;
+        switch (runtime) {
+            case 'node': {
+                // Node.js: Use fs.createReadStream and convert to Web Stream
+                const { createReadStream } = await import('fs');
+                const { Readable } = await import('stream');
+                const { stat } = await import('fs/promises');
+                // Check if file exists
+                try {
+                    await stat(localPath);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT') {
+                        throw new Error(`File not found: ${localPath}`);
+                    }
+                    throw error;
+                }
+                // Create Node.js readable stream from file
+                const nodeStream = createReadStream(localPath);
+                // Convert Node.js stream to Web ReadableStream (Node.js 17+)
+                webStream = Readable.toWeb(nodeStream);
+                break;
+            }
+            case 'deno': {
+                // Deno: Use Deno.open() to get a readable stream
+                const globalThisAny = globalThis;
+                const Deno = globalThisAny.Deno;
+                try {
+                    // Open file and get readable stream
+                    const file = await Deno.open(localPath, { read: true });
+                    webStream = file.readable;
+                }
+                catch (error) {
+                    if (error.name === 'NotFound') {
+                        throw new Error(`File not found: ${localPath}`);
+                    }
+                    throw error;
+                }
+                break;
+            }
+            case 'bun': {
+                // Bun: Use Bun.file() to get a stream
+                const globalThisAny = globalThis;
+                const Bun = globalThisAny.Bun;
+                try {
+                    const file = Bun.file(localPath);
+                    // Check if file exists by trying to get its size
+                    const exists = await file.exists();
+                    if (!exists) {
+                        throw new Error(`File not found: ${localPath}`);
+                    }
+                    // Get the stream
+                    webStream = await file.stream();
+                }
+                catch (error) {
+                    if (error.message?.includes('not found') || error.message?.includes('ENOENT')) {
+                        throw new Error(`File not found: ${localPath}`);
+                    }
+                    throw error;
+                }
+                break;
+            }
+            default:
+                throw new Error('uploadFileFromPath() is only available in Node.js, Deno, or Bun runtimes. ' +
+                    'Use uploadFileStream() with a ReadableStream in other runtimes (e.g., browser).');
+        }
+        // Use the existing streaming upload method
+        return this.uploadFileStream(remotePath, webStream, contentType);
+    }
+    /**
+     * Upload a file from various source types (convenience method)
+     * Works across browser, Node.js, Deno, Bun, and serverless environments
+     *
+     * Note: For large files, prefer uploadFileStream() with a ReadableStream
+     * to avoid loading the entire file into memory.
+     *
+     * @param path - Destination path for the file
+     * @param source - Source data: File, Blob, ArrayBuffer, Uint8Array, or string
+     * @param contentType - Optional MIME type
+     * @returns Upload response
+     *
+     * @example
+     * ```ts
+     * // From a File (browser)
+     * const fileInput = document.querySelector('input[type="file"]');
+     * await fs.uploadFile('/path/to/file.txt', fileInput.files[0]);
+     *
+     * // From a Blob
+     * const blob = new Blob(['content']);
+     * await fs.uploadFile('/path/to/file.txt', blob);
+     *
+     * // From a Uint8Array
+     * const data = new Uint8Array([1, 2, 3]);
+     * await fs.uploadFile('/path/to/file.txt', data);
+     *
+     * // From a string
+     * await fs.uploadFile('/path/to/file.txt', 'content');
+     * ```
+     */
+    async uploadFileFromSource(path, source, contentType) {
+        let body;
+        if (source instanceof File) {
+            // File is a subclass of Blob, use directly
+            body = source;
+        }
+        else if (source instanceof Blob) {
+            body = source;
+        }
+        else if (source instanceof ArrayBuffer) {
+            body = new Blob([source], { type: contentType || 'application/octet-stream' });
+        }
+        else if (source instanceof Uint8Array) {
+            // Uint8Array is compatible with Blob constructor in all runtimes
+            // Cast to any to avoid strict type checking issues with ArrayBufferLike vs ArrayBuffer
+            body = new Blob([source], { type: contentType || 'application/octet-stream' });
+        }
+        else if (typeof source === 'string') {
+            body = new Blob([source], { type: contentType || 'text/plain' });
+        }
+        else {
+            throw new Error(`Unsupported source type: ${typeof source}`);
+        }
+        // uploadFile returns plain text response, use Raw API
+        const rawResponse = await this.fsApi.uploadFileRaw({
+            id: this.sandboxId,
+            path,
+            body
+        });
+        // Extract the raw Response object
+        const response = rawResponse.raw;
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Upload failed: ${errorText}`);
+        }
+        // Return a normalized success response
+        const responseText = await response.text();
+        return {
+            status: 'success',
+            message: responseText || 'File uploaded successfully'
+        };
+    }
+    async deleteFile(path) {
+        return wrapRequest(this.fsApi.deleteFile({
+            id: this.sandboxId,
+            path
+        }));
+    }
+    async createDirectory(path) {
+        return wrapRequest(this.fsApi.createDirectory({
+            id: this.sandboxId,
+            path
+        }));
+    }
+    async createFile(path) {
+        return wrapRequest(this.fsApi.createFile({
+            id: this.sandboxId,
+            path
+        }));
+    }
+    async moveFile(from, to) {
+        return wrapRequest(this.fsApi.moveFile({
+            id: this.sandboxId,
+            from,
+            to
+        }));
+    }
+    async copyFile(from, to) {
+        return wrapRequest(this.fsApi.copyFile({
+            id: this.sandboxId,
+            from,
+            to
+        }));
+    }
+    async changePermissions(path, mode) {
+        return wrapRequest(this.fsApi.changePermissions({
+            id: this.sandboxId,
+            path,
+            mode
+        }));
+    }
+    async compressFile(path, format = 'tar.gz') {
+        const response = await wrapRequest(this.fsApi.compressFile({
+            id: this.sandboxId,
+            path,
+            format
+        }));
+        // Backend executes tar/zip command but doesn't return the archive path
+        // Construct it based on the source path and format
+        const cleanPath = path.startsWith('/') ? path : '/' + path;
+        let archivePath;
+        switch (format) {
+            case 'tar':
+                archivePath = `${cleanPath}.tar`;
+                break;
+            case 'tar.gz':
+                archivePath = `${cleanPath}.tar.gz`;
+                break;
+            case 'tar.bz2':
+                archivePath = `${cleanPath}.tar.bz2`;
+                break;
+            case 'zip':
+                archivePath = `${cleanPath}.zip`;
+                break;
+            default:
+                archivePath = `${cleanPath}.tar.gz`;
+        }
+        return { archivePath, ...response };
+    }
+    async statFile(path) {
+        const result = await wrapRequest(this.fsApi.statFile({
+            id: this.sandboxId,
+            path
+        }));
+        let info = {};
+        if (result?.data?.stdout) {
+            try {
+                info = JSON.parse(result.data.stdout.trim());
+            }
+            catch (e) {
+                info = {};
+            }
+        }
+        return { info, ...result };
+    }
+    async searchFiles(path, pattern = "*") {
+        const result = await wrapRequest(this.fsApi.searchFiles({
+            id: this.sandboxId,
+            path,
+            pattern
+        }));
+        let paths = [];
+        if (result?.data?.stdout) {
+            paths = result.data.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+        }
+        return { paths, ...result };
+    }
+    async headTail(path, options) {
+        const lines = options?.lines ?? 10;
+        const head = options?.head ?? true;
+        const result = await wrapRequest(this.fsApi.headTail({
+            id: this.sandboxId,
+            path,
+            lines,
+            head
+        }));
+        // Backend returns {status, message, data: {stdout: "...", exitCode: 0}}
+        let content = [];
+        if (result?.data?.stdout) {
+            const text = String(result.data.stdout);
+            content = text
+                .split(/\r?\n/)
+                .map((l) => l.trimEnd())
+                .filter((l) => l.length > 0);
+        }
+        return { content, ...result };
+    }
+    async extractArchive(archivePath, destPath) {
+        return wrapRequest(this.fsApi.extractArchive({
+            id: this.sandboxId,
+            archive: archivePath,
+            dest: destPath || "/tmp"
+        }));
+    }
+    async folderSize(path) {
+        const result = await wrapRequest(this.fsApi.diskUsage({
+            id: this.sandboxId,
+            path
+        }));
+        // Backend returns {status, message, data: {stdout: "4.0K\t/tmp/fs-e2e", exitCode: 0}}
+        // Parse the du output from stdout (format: "SIZE\tPATH")
+        let info = {};
+        if (result?.data?.stdout) {
+            const output = result.data.stdout.trim();
+            const parts = output.split(/\s+/);
+            if (parts.length >= 2) {
+                const rawSize = parts[0];
+                info.size = Number(rawSize.replace(/[KMG]$/, ''));
+                if (rawSize.endsWith('K'))
+                    info.unit = 'KB';
+                else if (rawSize.endsWith('M'))
+                    info.unit = 'MB';
+                else if (rawSize.endsWith('G'))
+                    info.unit = 'GB';
+                else
+                    info.unit = 'KB'; // Default to KB if no suffix (du -h usually adds it)
+            }
+        }
+        return { info, ...result };
+    }
+}
+//# sourceMappingURL=FS.js.map