@larkup/sandbox 0.1.1 → 0.1.3

package/.turbo/turbo-build.log

@@ -1,6 +1,4 @@
-(node:18200) Warning: The 'NO_COLOR' env is ignored due to the 'FORCE_COLOR' env being set.
-(Use `node --trace-warnings ...` to show where the warning was created)
 
-> @larkup/sandbox@0.1.0 build /Users/abdelrahmanabounida/Desktop/my-ai-startup/larkup/larkup/packages/sandbox
-> tsc --outDir dist
+> @larkup/sandbox@0.1.3 build /home/runner/work/larkup/larkup/packages/sandbox
+> tsc -p tsconfig.build.json --outDir dist
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @larkup/sandbox
 
+## 0.1.3
+
+### Patch Changes
+
+- Add a Docker-free local runtime for trusted Python and JavaScript analysis, alongside hardened provider verification and reusable remote snapshots.
+
+## 0.1.2
+
+### Patch Changes
+
+- fix: lazy-import dockerode to prevent Turbopack hash mangling at runtime
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/docker-runner.js

@@ -5,7 +5,6 @@
  * Each execution spins up a container, runs the code, captures output +
  * generated files, then auto-removes the container.
  */
-import Docker from 'dockerode';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
@@ -15,17 +14,17 @@ const OUTPUT_DIR = '/sandbox/output';
 const INPUT_DIR = '/sandbox/input';
 const DOCKERFILE_DIR = path.join(import.meta.dirname ?? __dirname, '..');
 let dockerInstance = null;
-function getDocker() {
+async function getDocker() {
     if (!dockerInstance) {
+        // Dynamic import prevents Turbopack from statically bundling dockerode
+        // and mangling its module name with a hash suffix.
+        const { default: Docker } = await import(/* turbopackIgnore: true */ 'dockerode');
         dockerInstance = new Docker();
     }
     return dockerInstance;
 }
-/* ------------------------------------------------------------------ */
-/* Health check                                                        */
-/* ------------------------------------------------------------------ */
 export async function checkDockerHealth() {
-    const docker = getDocker();
+    const docker = await getDocker();
     try {
         const info = await docker.version();
         const images = await docker.listImages({
@@ -39,18 +38,19 @@ export async function checkDockerHealth() {
         };
     }
     catch (err) {
+        const raw = err?.message ?? '';
+        const dockerMissing = /ENOENT|ECONNREFUSED|EACCES|no such file|cannot connect to the docker daemon/i.test(raw);
         return {
             status: 'docker-not-found',
             backend: 'docker',
-            error: err.message ?? 'Docker daemon not available',
+            error: dockerMissing
+                ? "Docker isn't installed or running on this machine. Local code execution is optional — install Docker Desktop to enable it, or configure a remote sandbox provider below."
+                : raw || 'Docker daemon not available',
         };
     }
 }
-/* ------------------------------------------------------------------ */
-/* Image management                                                    */
-/* ------------------------------------------------------------------ */
 export async function buildSandboxImage(onProgress) {
-    const docker = getDocker();
+    const docker = await getDocker();
     const dockerfilePath = path.join(DOCKERFILE_DIR, 'Dockerfile');
     // Check if Dockerfile exists in the package
     try {
@@ -78,7 +78,7 @@ export async function buildSandboxImage(onProgress) {
     onProgress?.('Sandbox image built successfully ✓');
 }
 export async function ensureImage() {
-    const docker = getDocker();
+    const docker = await getDocker();
     const images = await docker.listImages({
         filters: { reference: [SANDBOX_IMAGE] },
     });
@@ -92,9 +92,6 @@ export async function ensureImage() {
         return false;
     }
 }
-/* ------------------------------------------------------------------ */
-/* Code execution                                                      */
-/* ------------------------------------------------------------------ */
 /**
  * Build the Python wrapper script that:
  * 1. Sets up pandas compatibility shims to handle deprecated APIs
@@ -247,7 +244,7 @@ if artifacts:
 `;
 }
 export async function executeInDocker(request, config) {
-    const docker = getDocker();
+    const docker = await getDocker();
     const startTime = Date.now();
     // Create a temporary directory for input files
     const tmpDir = path.join(os.tmpdir(), `larkup-sandbox-${randomUUID()}`);
@@ -258,6 +255,20 @@ export async function executeInDocker(request, config) {
     // Write input files
     if (request.files) {
         for (const file of request.files) {
+            if (!file.name ||
+                file.name === '.' ||
+                file.name === '..' ||
+                file.name.includes('/') ||
+                file.name.includes('\\') ||
+                file.name.includes('\0')) {
+                return {
+                    stdout: '',
+                    stderr: 'Sandbox file names must be plain file names.',
+                    exitCode: 1,
+                    artifacts: [],
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
             const filePath = path.join(inputDir, file.name);
             if (file.isBase64) {
                 await fs.writeFile(filePath, Buffer.from(file.content, 'base64'));
@@ -270,16 +281,19 @@ export async function executeInDocker(request, config) {
     // Prepare the execution code
     let execCode;
     let cmd;
+    let scriptName;
     if (request.language === 'python') {
         execCode = wrapPythonCode(request.code);
         const scriptPath = path.join(tmpDir, 'run.py');
         await fs.writeFile(scriptPath, execCode, 'utf8');
+        scriptName = 'run.py';
         cmd = ['python3', '/sandbox/run.py'];
     }
     else {
         // JavaScript/TypeScript (future)
         const scriptPath = path.join(tmpDir, 'run.js');
         await fs.writeFile(scriptPath, request.code, 'utf8');
+        scriptName = 'run.js';
         cmd = ['node', '/sandbox/run.js'];
     }
     const timeout = request.timeout ?? config.timeoutMs;
@@ -298,7 +312,7 @@ export async function executeInDocker(request, config) {
                 Binds: [
                     `${inputDir}:${INPUT_DIR}:ro`,
                     `${outputDir}:${OUTPUT_DIR}:rw`,
-                    `${tmpDir}/run.py:/sandbox/run.py:ro`,
+                    `${tmpDir}/${scriptName}:/sandbox/${scriptName}:ro`,
                 ],
                 ReadonlyRootfs: false,
             },
@@ -309,8 +323,9 @@ export async function executeInDocker(request, config) {
         await container.start();
         // Wait for completion with timeout
         const waitPromise = container.wait();
+        let timeoutHandle;
         const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(async () => {
+            timeoutHandle = setTimeout(async () => {
                 try {
                     await container?.kill();
                 }
@@ -321,6 +336,8 @@ export async function executeInDocker(request, config) {
             }, timeout);
         });
         const result = await Promise.race([waitPromise, timeoutPromise]);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
         // Capture logs
         const logs = await container.logs({
             stdout: true,
@@ -384,9 +401,6 @@ export async function executeInDocker(request, config) {
         }
     }
 }
-/* ------------------------------------------------------------------ */
-/* Helpers                                                             */
-/* ------------------------------------------------------------------ */
 /**
  * Docker multiplexes stdout/stderr into a single stream with 8-byte headers.
  * Header format: [type(1)][0(3)][size(4)] where type: 1=stdout, 2=stderr

package/dist/index.d.ts

@@ -3,6 +3,8 @@
  *
  * Re-exports the public API for the sandbox package.
  */
-export { SandboxManager } from './sandbox-manager.js';
+export { SandboxManager, verifySandboxProvider } from './sandbox-manager.js';
 export { checkDockerHealth, buildSandboxImage, ensureImage, executeInDocker, } from './docker-runner.js';
-export type { SandboxBackend, SandboxConfig, DockerConfig, RemoteConfig, SandboxLanguage, SandboxFile, ExecutionRequest, ExecutionResult, ExecutionArtifact, SandboxStatus, SandboxHealthCheck, } from './types.js';
+export { checkLocalRuntime, executeLocally } from './local-runner.js';
+export { SANDBOX_PROVIDERS, SANDBOX_PROVIDER_LIST, getSandboxProvider, validateSandboxCredentials, } from './registry.js';
+export type { SandboxBackend, SandboxConfig, DockerConfig, SandboxLanguage, SandboxFile, ExecutionRequest, ExecutionResult, ExecutionArtifact, SandboxStatus, SandboxHealthCheck, SandboxCredentialField, SandboxProviderDescriptor, SandboxProviderAdapter, } from './types.js';

package/dist/index.js

@@ -3,5 +3,7 @@
  *
  * Re-exports the public API for the sandbox package.
  */
-export { SandboxManager } from './sandbox-manager.js';
+export { SandboxManager, verifySandboxProvider } from './sandbox-manager.js';
 export { checkDockerHealth, buildSandboxImage, ensureImage, executeInDocker, } from './docker-runner.js';
+export { checkLocalRuntime, executeLocally } from './local-runner.js';
+export { SANDBOX_PROVIDERS, SANDBOX_PROVIDER_LIST, getSandboxProvider, validateSandboxCredentials, } from './registry.js';

package/dist/local-runner.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutionRequest, ExecutionResult, SandboxHealthCheck } from './types.js';
+/** Checks whether the host can run Python analysis without Docker. */
+export declare function checkLocalRuntime(): Promise<SandboxHealthCheck>;
+/** Executes trusted code in a temporary host workspace and collects its output. */
+export declare function executeLocally(request: ExecutionRequest): Promise<ExecutionResult>;

package/dist/local-runner.js

@@ -0,0 +1,176 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { getMimeType } from './mime.js';
+let pythonCommand;
+function run(command, args, cwd, timeoutMs = 10_000) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command.executable, [...command.args, ...args], {
+            cwd,
+            env: process.env,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        // Node ChildProcess is an EventEmitter at runtime. TypeScript 7's narrowed stdio return type
+        // omits that inherited surface, so retain it explicitly for lifecycle events.
+        const lifecycle = child;
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout = (stdout + chunk).slice(-1_000_000);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr = (stderr + chunk).slice(-1_000_000);
+        });
+        lifecycle.once('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        lifecycle.once('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                stdout,
+                stderr: timedOut ? `${stderr}\nExecution timed out.`.trim() : stderr,
+                exitCode: timedOut ? 124 : code ?? 1,
+            });
+        });
+    });
+}
+async function resolvePython() {
+    if (pythonCommand !== undefined)
+        return pythonCommand;
+    const candidates = process.env.LARKUP_PYTHON
+        ? [{ executable: process.env.LARKUP_PYTHON, args: [] }]
+        : process.platform === 'win32'
+            ? [
+                { executable: 'py', args: ['-3'] },
+                { executable: 'python', args: [] },
+            ]
+            : [
+                { executable: 'python3', args: [] },
+                { executable: 'python', args: [] },
+            ];
+    for (const candidate of candidates) {
+        try {
+            if ((await run(candidate, ['--version'])).exitCode === 0) {
+                pythonCommand = candidate;
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    pythonCommand = null;
+    return null;
+}
+function assertSafeFileName(name) {
+    if (!name || name === '.' || name === '..' || /[\\/\0]/.test(name)) {
+        throw new Error('Sandbox file names must be plain file names.');
+    }
+}
+function pythonWrapper(code, outputDir) {
+    return `import base64, os, sys, traceback
+os.makedirs(${JSON.stringify(outputDir)}, exist_ok=True)
+os.environ.setdefault('MPLBACKEND', 'Agg')
+try:
+    import numpy as np
+    import pandas as pd
+except ImportError:
+    pass
+try:
+    import matplotlib
+    matplotlib.use('Agg')
+    import matplotlib.pyplot as plt
+    def _save_figures(*args, **kwargs):
+        for i, number in enumerate(plt.get_fignums()):
+            plt.figure(number).savefig(os.path.join(${JSON.stringify(outputDir)}, f'chart_{i}.png'), dpi=150, bbox_inches='tight')
+        plt.close('all')
+    plt.show = _save_figures
+except ImportError:
+    pass
+try:
+    exec(compile(base64.b64decode(${JSON.stringify(Buffer.from(code).toString('base64'))}), 'analysis.py', 'exec'))
+    if 'plt' in globals() and plt.get_fignums():
+        plt.show()
+except Exception as error:
+    traceback.print_exception(error, file=sys.stderr)
+    sys.exit(1)
+`;
+}
+/** Checks whether the host can run Python analysis without Docker. */
+export async function checkLocalRuntime() {
+    const python = await resolvePython();
+    if (!python) {
+        return {
+            status: 'error',
+            backend: 'local',
+            error: 'Local code execution needs Python 3. Install Python or choose Docker or a remote sandbox provider.',
+        };
+    }
+    return { status: 'ready', backend: 'local' };
+}
+/** Executes trusted code in a temporary host workspace and collects its output. */
+export async function executeLocally(request) {
+    const startTime = Date.now();
+    const tempDir = path.join(os.tmpdir(), `larkup-local-${randomUUID()}`);
+    const inputDir = path.join(tempDir, 'input');
+    const outputDir = path.join(tempDir, 'output');
+    try {
+        await fs.mkdir(inputDir, { recursive: true });
+        await fs.mkdir(outputDir, { recursive: true });
+        for (const file of request.files ?? []) {
+            assertSafeFileName(file.name);
+            await fs.writeFile(path.join(inputDir, file.name), file.isBase64 ? Buffer.from(file.content, 'base64') : file.content);
+        }
+        const isPython = request.language === 'python';
+        const command = isPython ? await resolvePython() : { executable: process.execPath, args: [] };
+        if (!command) {
+            return {
+                stdout: '',
+                stderr: 'Local code execution needs Python 3. Install Python or choose Docker or a remote sandbox provider.',
+                exitCode: 1,
+                artifacts: [],
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        const script = path.join(tempDir, isPython ? 'run.py' : 'run.js');
+        const source = isPython
+            ? pythonWrapper(request.code, outputDir)
+            : `process.env.LARKUP_OUTPUT_DIR = ${JSON.stringify(outputDir)};\n${request.code}`;
+        await fs.writeFile(script, source, 'utf8');
+        const result = await run(command, [script], inputDir, request.timeout ?? 30_000);
+        const artifacts = [];
+        for (const name of await fs.readdir(outputDir).catch(() => [])) {
+            const filePath = path.join(outputDir, name);
+            const stat = await fs.stat(filePath).catch(() => null);
+            if (!stat?.isFile())
+                continue;
+            artifacts.push({
+                name,
+                mimeType: getMimeType(name),
+                data: (await fs.readFile(filePath)).toString('base64'),
+            });
+        }
+        return { ...result, artifacts, executionTimeMs: Date.now() - startTime };
+    }
+    catch (error) {
+        return {
+            stdout: '',
+            stderr: error instanceof Error ? error.message : 'Local execution failed.',
+            exitCode: 1,
+            artifacts: [],
+            executionTimeMs: Date.now() - startTime,
+        };
+    }
+    finally {
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    }
+}

package/dist/mime.d.ts

@@ -0,0 +1 @@
+export declare function getMimeType(filename: string): string;

package/dist/mime.js

@@ -0,0 +1,16 @@
+const MIME_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    svg: 'image/svg+xml',
+    gif: 'image/gif',
+    csv: 'text/csv',
+    json: 'application/json',
+    txt: 'text/plain',
+    html: 'text/html',
+    pdf: 'application/pdf',
+};
+export function getMimeType(filename) {
+    const ext = filename.slice(filename.lastIndexOf('.') + 1).toLowerCase();
+    return MIME_TYPES[ext] ?? 'application/octet-stream';
+}

package/dist/providers/browserbase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browserbase adapter — https://docs.browserbase.com/welcome/introduction
+ *
+ * Browserbase provisions headless-Chrome sessions for Playwright/Puppeteer
+ * automation, not an arbitrary code-execution sandbox — see
+ * SANDBOX_PROVIDERS.browserbase.executionCaveat. `execute()` fails fast with
+ * that explanation instead of pretending to run Python/JS here.
+ * `verifyCredentials`/`healthCheck` are still fully real: they confirm the
+ * API key and project actually work.
+ */
+import type { SandboxProviderAdapter } from '../types.js';
+export declare const browserbaseAdapter: SandboxProviderAdapter;

package/dist/providers/browserbase.js

@@ -0,0 +1,61 @@
+/**
+ * Browserbase adapter — https://docs.browserbase.com/welcome/introduction
+ *
+ * Browserbase provisions headless-Chrome sessions for Playwright/Puppeteer
+ * automation, not an arbitrary code-execution sandbox — see
+ * SANDBOX_PROVIDERS.browserbase.executionCaveat. `execute()` fails fast with
+ * that explanation instead of pretending to run Python/JS here.
+ * `verifyCredentials`/`healthCheck` are still fully real: they confirm the
+ * API key and project actually work.
+ */
+import { failedResult } from '../remote-exec.js';
+import { SANDBOX_PROVIDERS } from '../registry.js';
+async function loadSdk() {
+    return (await import('@browserbasehq/sdk'));
+}
+function requireFields(credentials) {
+    const apiKey = credentials.apiKey?.trim();
+    const projectId = credentials.projectId?.trim();
+    if (!apiKey || !projectId)
+        throw new Error('Browserbase API key and project ID are both required.');
+    return { apiKey, projectId };
+}
+async function verifyCredentials(credentials) {
+    const { apiKey, projectId } = requireFields(credentials);
+    const { default: Browserbase } = await loadSdk();
+    const client = new Browserbase({ apiKey });
+    const projects = await client.projects.list();
+    if (!projects.some((project) => project.id === projectId)) {
+        throw new Error('This API key cannot see the given Browserbase project ID.');
+    }
+}
+async function healthCheck(credentials) {
+    const caveat = SANDBOX_PROVIDERS.browserbase.executionCaveat;
+    if (!credentials.apiKey?.trim() || !credentials.projectId?.trim()) {
+        return {
+            status: 'missing-credentials',
+            backend: 'browserbase',
+            error: 'Browserbase API key and project ID are required.',
+        };
+    }
+    try {
+        await verifyCredentials(credentials);
+        return { status: 'unsupported', backend: 'browserbase', error: caveat };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            backend: 'browserbase',
+            error: err instanceof Error ? err.message : 'Browserbase health check failed.',
+        };
+    }
+}
+async function execute(_request, _credentials) {
+    return failedResult(SANDBOX_PROVIDERS.browserbase.executionCaveat, Date.now());
+}
+export const browserbaseAdapter = {
+    id: 'browserbase',
+    verifyCredentials,
+    healthCheck,
+    execute,
+};

package/dist/providers/cloudflare.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cloudflare Sandbox adapter — https://developers.cloudflare.com/sandbox/
+ */
+import type { SandboxProviderAdapter } from '../types.js';
+export declare const cloudflareAdapter: SandboxProviderAdapter;

package/dist/providers/cloudflare.js

@@ -0,0 +1,55 @@
+/**
+ * Cloudflare Sandbox adapter — https://developers.cloudflare.com/sandbox/
+ */
+import { failedResult } from '../remote-exec.js';
+import { SANDBOX_PROVIDERS } from '../registry.js';
+function requireFields(credentials) {
+    const apiToken = credentials.apiToken?.trim();
+    const accountId = credentials.accountId?.trim();
+    if (!apiToken || !accountId)
+        throw new Error('Cloudflare API token and account ID are both required.');
+    return { apiToken, accountId };
+}
+async function verifyCredentials(credentials) {
+    const { apiToken, accountId } = requireFields(credentials);
+    const tokenRes = await fetch('https://api.cloudflare.com/client/v4/user/tokens/verify', {
+        headers: { Authorization: `Bearer ${apiToken}` },
+    });
+    if (!tokenRes.ok)
+        throw new Error(`Cloudflare rejected the API token (${tokenRes.status}).`);
+    const accountRes = await fetch(`https://api.cloudflare.com/client/v4/accounts/${accountId}`, {
+        headers: { Authorization: `Bearer ${apiToken}` },
+    });
+    if (!accountRes.ok)
+        throw new Error('This API token cannot see the given Cloudflare account ID.');
+}
+async function healthCheck(credentials) {
+    const caveat = SANDBOX_PROVIDERS.cloudflare.executionCaveat;
+    if (!credentials.apiToken?.trim() || !credentials.accountId?.trim()) {
+        return {
+            status: 'missing-credentials',
+            backend: 'cloudflare',
+            error: 'Cloudflare API token and account ID are required.',
+        };
+    }
+    try {
+        await verifyCredentials(credentials);
+        return { status: 'unsupported', backend: 'cloudflare', error: caveat };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            backend: 'cloudflare',
+            error: err instanceof Error ? err.message : 'Cloudflare health check failed.',
+        };
+    }
+}
+async function execute(_request, _credentials) {
+    return failedResult(SANDBOX_PROVIDERS.cloudflare.executionCaveat, Date.now());
+}
+export const cloudflareAdapter = {
+    id: 'cloudflare',
+    verifyCredentials,
+    healthCheck,
+    execute,
+};

package/dist/providers/daytona.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Daytona adapter — https://www.daytona.io/docs/en/sandboxes/
+ *
+ * Daytona's `process.executeCommand` result doesn't document a separate
+ * stderr field (output comes back merged into `result`), so unlike the
+ * other adapters we can't cleanly split stdout/stderr — everything lands in
+ * stdout, and the combined output is mirrored into stderr only when the
+ * command actually failed (exitCode !== 0), so error output still surfaces
+ * where callers expect it.
+ */
+import type { SandboxProviderAdapter } from '../types.js';
+export declare const daytonaAdapter: SandboxProviderAdapter;

package/dist/providers/daytona.js

@@ -0,0 +1,84 @@
+/**
+ * Daytona adapter — https://www.daytona.io/docs/en/sandboxes/
+ *
+ * Daytona's `process.executeCommand` result doesn't document a separate
+ * stderr field (output comes back merged into `result`), so unlike the
+ * other adapters we can't cleanly split stdout/stderr — everything lands in
+ * stdout, and the combined output is mirrored into stderr only when the
+ * command actually failed (exitCode !== 0), so error output still surfaces
+ * where callers expect it.
+ */
+import { DEFAULT_TIMEOUT_MS, failedResult, runScriptedExecution, safeCleanup, withTimeout, } from '../remote-exec.js';
+async function loadSdk() {
+    return (await import('@daytonaio/sdk'));
+}
+function requireFields(credentials) {
+    const apiKey = credentials.apiKey?.trim();
+    if (!apiKey)
+        throw new Error('Daytona API key is required.');
+    return { apiKey, apiUrl: credentials.apiUrl?.trim() || undefined };
+}
+async function verifyCredentials(credentials) {
+    const fields = requireFields(credentials);
+    const { Daytona } = await loadSdk();
+    const daytona = new Daytona(fields);
+    await daytona.list().next();
+}
+async function healthCheck(credentials) {
+    if (!credentials.apiKey?.trim()) {
+        return {
+            status: 'missing-credentials',
+            backend: 'daytona',
+            error: 'Daytona API key is required.',
+        };
+    }
+    try {
+        await verifyCredentials(credentials);
+        return { status: 'ready', backend: 'daytona' };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            backend: 'daytona',
+            error: err instanceof Error ? err.message : 'Daytona health check failed.',
+        };
+    }
+}
+async function execute(request, credentials) {
+    const startTime = Date.now();
+    let fields;
+    try {
+        fields = requireFields(credentials);
+    }
+    catch (err) {
+        return failedResult(err instanceof Error ? err.message : 'Missing Daytona credentials.', startTime);
+    }
+    const timeoutMs = request.timeout ?? DEFAULT_TIMEOUT_MS;
+    let sandbox;
+    try {
+        const { Daytona } = await loadSdk();
+        const daytona = new Daytona(fields);
+        const snapshot = credentials.snapshot?.trim();
+        sandbox = await withTimeout(daytona.create(snapshot ? { snapshot } : { language: 'python' }), timeoutMs + 30_000, 'Daytona sandbox create');
+        const activeSandbox = sandbox;
+        return await withTimeout(runScriptedExecution(async (script) => {
+            const result = await activeSandbox.process.executeCommand(script, undefined, undefined, timeoutMs / 1000);
+            const exitCode = result.exitCode ?? 0;
+            const output = result.result ?? '';
+            return { stdout: output, stderr: exitCode !== 0 ? output : '', exitCode };
+        }, request), timeoutMs + 15_000, 'Daytona execution');
+    }
+    catch (err) {
+        return failedResult(err instanceof Error ? err.message : 'Daytona execution failed.', startTime);
+    }
+    finally {
+        if (sandbox)
+            await safeCleanup(() => sandbox.delete());
+    }
+}
+export const daytonaAdapter = {
+    id: 'daytona',
+    verifyCredentials,
+    healthCheck,
+    execute,
+};

package/dist/providers/e2b.d.ts

@@ -0,0 +1,9 @@
+/**
+ * E2B adapter — https://docs.e2b.dev/
+ *
+ * Uses the base `e2b` SDK (not `@e2b/code-interpreter`) so execution stays a
+ * plain "run this shell script, get stdout/stderr/exitCode" call, matching
+ * every other remote adapter and letting them share `runScriptedExecution`.
+ */
+import type { SandboxProviderAdapter } from '../types.js';
+export declare const e2bAdapter: SandboxProviderAdapter;