@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/docker-archive-utils.js

@@ -0,0 +1,50 @@
+import tar from 'tar-stream';
+export async function getFileFromContainer(container, filePath) {
+    let archiveStream;
+    try {
+        archiveStream = await container.getArchive({ path: filePath });
+    }
+    catch (err) {
+        if (err?.statusCode === 404 || err?.reason?.includes?.('No such container')) {
+            throw new Error(`File not found in container: ${filePath}`);
+        }
+        throw new Error(`Failed to read file from container: ${filePath} — ${err?.message || err}`);
+    }
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        const extract = tar.extract();
+        extract.on('entry', (_header, stream, next) => {
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('end', next);
+            stream.resume();
+        });
+        extract.on('finish', () => resolve(Buffer.concat(chunks)));
+        extract.on('error', reject);
+        archiveStream.on('error', (err) => {
+            reject(new Error(`Failed to read file from container: ${filePath} — ${err.message}`));
+        });
+        archiveStream.pipe(extract);
+    });
+}
+function archivePath(filePath) {
+    return filePath.replace(/^\/+/, '');
+}
+function parentDirectories(filePath) {
+    const parts = archivePath(filePath).split('/').slice(0, -1);
+    const dirs = [];
+    for (let i = 1; i <= parts.length; i++) {
+        dirs.push(parts.slice(0, i).join('/'));
+    }
+    return dirs;
+}
+export async function putFileToContainer(container, filePath, content) {
+    const pack = tar.pack();
+    for (const dir of parentDirectories(filePath)) {
+        pack.entry({ name: dir, type: 'directory', mode: 0o755 }, Buffer.alloc(0));
+    }
+    pack.entry({ name: archivePath(filePath) }, content);
+    pack.finalize();
+    // Delegate placement to Docker Engine archive extraction instead of doing
+    // host-side temp-file rename/copy operations across bind mounts.
+    await container.putArchive(pack, { path: '/', noOverwriteDirNonDir: '1' });
+}

package/dist/sandbox/core/docker-sandbox.d.ts

@@ -0,0 +1,51 @@
+import Dockerode from 'dockerode';
+import type { Sandbox, SandboxBackgroundCommandOptions, SandboxBackgroundOutput, SandboxBackgroundStartResult, SandboxBackgroundStatus, SandboxCommandOptions, SandboxProcessResult, SandboxSessionResult, SandboxFileInfo, SandboxFileSearchResult, SandboxMatch, SandboxPreviewLink } from './types.js';
+export declare class DockerSandbox implements Sandbox {
+    private docker;
+    private container;
+    private _state;
+    private _workDir;
+    private _id;
+    private backgroundCommands;
+    constructor(docker: Dockerode, container: Dockerode.Container, workDir: string);
+    get id(): string;
+    get state(): string;
+    refreshData(): Promise<void>;
+    start(): Promise<void>;
+    delete(): Promise<void>;
+    deleteSync(): void;
+    get process(): {
+        executeCommand: (command: string, cwd?: string | SandboxCommandOptions) => Promise<SandboxProcessResult>;
+        startBackgroundCommand: (command: string, opts?: SandboxBackgroundCommandOptions) => Promise<SandboxBackgroundStartResult>;
+        getBackgroundCommand: (cmdId: string) => Promise<SandboxBackgroundStatus>;
+        readBackgroundCommand: (cmdId: string, opts?: {
+            maxOutputBytes?: number;
+            maxOutputLines?: number;
+        }) => Promise<SandboxBackgroundOutput>;
+        stopBackgroundCommand: (cmdId: string) => Promise<SandboxBackgroundStatus>;
+        createSession: (sessionId: string) => Promise<void>;
+        getSession: (sessionId: string) => Promise<void>;
+        executeSessionCommand: (sessionId: any, opts: any) => Promise<SandboxSessionResult>;
+    };
+    get fs(): {
+        downloadFile: (filePath: string) => Promise<Buffer>;
+        uploadFile: (content: Buffer, filePath: string) => Promise<void>;
+        createFolder: (path: string, mode?: string) => Promise<void>;
+        listFiles: (dirPath: string) => Promise<SandboxFileInfo[]>;
+        searchFiles: (path: string, pattern: string) => Promise<SandboxFileSearchResult>;
+        findFiles: (path: string, pattern: string) => Promise<SandboxMatch[]>;
+    };
+    getWorkDir(): Promise<string>;
+    getPreviewLink(port: number): Promise<SandboxPreviewLink>;
+    private executeManagedCommand;
+    private startManagedShellCommand;
+    private runnerScript;
+    private writeContainerTextFile;
+    private getManagedCommandStatus;
+    private readManagedCommandOutput;
+    private stopManagedCommand;
+    private containerFileSize;
+    private containerFileLineCount;
+    private readContainerTextTail;
+    private persistFullOutput;
+}