@openai/agents-extensions 0.8.5 → 0.9.0

package/dist/sandbox/daytona/sandbox.mjs

@@ -0,0 +1,900 @@
+import { UserError } from '@openai/agents-core';
+import { SandboxProviderError, SandboxUnsupportedFeatureError, normalizeSandboxClientCreateArgs, } from '@openai/agents-core/sandbox';
+import { appendPtyOutput, assertCoreSnapshotUnsupported, assertTarWorkspacePersistence, createPtyProcessEntry, imageOutputFromBytes, RemoteSandboxEditor, assertSandboxEntryMetadataSupported, assertSandboxManifestMetadataSupported, MOUNT_MANIFEST_METADATA_SUPPORT, closeRemoteSessionOnManifestError, cloneManifestWithRoot, createRunAsRemoteEditor, deserializeRemoteSandboxSessionStateValues, elapsedSeconds, formatExecResponse, formatPtyExecUpdate, hydrateRemoteWorkspaceTar, assertResumeRecreateAllowed, materializeEnvironment, manifestMaterializationOptionsWithRunAs, persistRemoteWorkspaceTar, assertConfiguredExposedPort, getCachedExposedPortEndpoint, parseExposedPortEndpoint, recordResolvedExposedPortEndpoint, resolveSandboxAbsolutePath, resolveSandboxWorkdir, posixDirname, shellQuote, sandboxUserShellCommand, shellCommandForPty, serializeRemoteSandboxSessionState, truncateOutput, validateRemoteSandboxPathForManifest, watchPtyProcess, readOptionalNumber, readOptionalNumberArray, readOptionalRecord, readOptionalString, readString, withProviderError, withSandboxSpan, writePtyStdin, PtyProcessRegistry, readRunAsRemoteFile, runAsRemotePathExists, } from "../shared/index.mjs";
+import { mountRcloneCloudBucket, rclonePatternFromMountStrategy, unmountRcloneMount, } from "../shared/inContainerMounts.mjs";
+import { isDaytonaCloudBucketMountEntry } from "./mounts.mjs";
+import { applyLocalSourceManifestEntryToState, applyLocalSourceManifestToState, materializeLocalSourceManifest, } from "../shared/localSources.mjs";
+const DEFAULT_WORKSPACE_ROOT = '/home/daytona/workspace';
+const DEFAULT_EXPOSED_PORT_URL_TTL_S = 60;
+const DAYTONA_DELETE_RETRY_DELAYS_MS = [1_000, 2_000, 4_000];
+export class DaytonaSandboxSession {
+    state;
+    sandbox;
+    ptyProcesses = new PtyProcessRegistry();
+    remotePathResolver = async (path, options) => await this.resolveRemotePath(path, options);
+    activeMountPaths = new Set();
+    concurrencyLimits;
+    stopPromise;
+    deletePromise;
+    constructor(args) {
+        this.state = args.state;
+        this.sandbox = args.sandbox;
+        this.concurrencyLimits = args.concurrencyLimits;
+    }
+    createEditor(runAs) {
+        if (runAs) {
+            return createRunAsRemoteEditor({
+                providerName: 'DaytonaSandboxClient',
+                providerId: 'daytona',
+                runAs,
+                resolvePath: this.remotePathResolver,
+                runCommand: this.runAsCommandRunner.bind(this),
+                writer: this.writer(),
+            });
+        }
+        return new RemoteSandboxEditor({
+            resolvePath: this.remotePathResolver,
+            pathExists: async (path) => await this.pathExists(path),
+            mkdir: async (path) => {
+                await this.mkdirEditorPath(path);
+            },
+            readText: async (path) => {
+                return await this.readEditorText(path);
+            },
+            writeText: async (path, content) => {
+                await this.writeEditorText(path, content);
+            },
+            deletePath: async (path) => {
+                await this.deleteEditorPath(path);
+            },
+        });
+    }
+    supportsPty() {
+        return typeof this.sandbox.process.createPty === 'function';
+    }
+    async execCommand(args) {
+        if (args.tty) {
+            return await this.execPtyCommand(args);
+        }
+        const start = Date.now();
+        const result = await this.sandbox.process.executeCommand(commandForDaytonaUser(args.cmd, args.runAs), resolveSandboxWorkdir(this.state.manifest.root, args.workdir), this.state.environment);
+        const combinedOutput = result.artifacts?.stdout ?? result.result ?? '';
+        const output = truncateOutput(combinedOutput, args.maxOutputTokens);
+        return formatExecResponse({
+            output: output.text,
+            wallTimeSeconds: elapsedSeconds(start),
+            exitCode: result.exitCode,
+            originalTokenCount: output.originalTokenCount,
+        });
+    }
+    async writeStdin(args) {
+        return await writePtyStdin({
+            providerName: 'DaytonaSandboxClient',
+            registry: this.ptyProcesses,
+            sessionId: args.sessionId,
+            chars: args.chars,
+            yieldTimeMs: args.yieldTimeMs,
+            maxOutputTokens: args.maxOutputTokens,
+        });
+    }
+    async execPtyCommand(args) {
+        if (!this.sandbox.process.createPty) {
+            throw new SandboxUnsupportedFeatureError('DaytonaSandboxClient tty=true requires Daytona SDK PTY support.', {
+                provider: 'daytona',
+                feature: 'tty',
+            });
+        }
+        const start = Date.now();
+        const command = shellCommandForPty(args);
+        const entry = createPtyProcessEntry({ tty: true });
+        const providerSessionId = `sandbox-${Math.random().toString(16).slice(2, 14)}`;
+        const handle = await this.sandbox.process.createPty({
+            id: providerSessionId,
+            cwd: resolveSandboxWorkdir(this.state.manifest.root, args.workdir),
+            envs: this.state.environment,
+            cols: 80,
+            rows: 24,
+            onData: (data) => appendPtyOutput(entry, data),
+        });
+        if (handle.waitForConnection) {
+            await handle.waitForConnection();
+        }
+        if (!handle.sendInput) {
+            await this.terminatePtyHandle(handle, providerSessionId);
+            throw new SandboxUnsupportedFeatureError('DaytonaSandboxClient tty=true requires Daytona SDK PTY stdin support.', {
+                provider: 'daytona',
+                feature: 'tty.stdin',
+            });
+        }
+        if (!handle.wait) {
+            await this.terminatePtyHandle(handle, providerSessionId);
+            throw new SandboxUnsupportedFeatureError('DaytonaSandboxClient tty=true requires Daytona SDK PTY wait support.', {
+                provider: 'daytona',
+                feature: 'tty.wait',
+            });
+        }
+        const waitForExit = handle.wait.bind(handle);
+        entry.sendInput = async (chars) => {
+            await handle.sendInput(chars);
+        };
+        entry.terminate = async () => {
+            if (handle.kill) {
+                await handle.kill();
+            }
+            else {
+                await this.sandbox.process.killPtySession?.(handle.sessionId ?? providerSessionId);
+            }
+            await handle.disconnect?.();
+        };
+        const { sessionId, pruned } = this.ptyProcesses.register(entry);
+        if (pruned) {
+            await pruned.terminate?.().catch(() => { });
+        }
+        watchPtyProcess(entry, async () => await waitForExit(), (result, error) => exitCodeFromDaytonaResult(result) ??
+            exitCodeFromDaytonaResult(error) ??
+            exitCodeFromDaytonaResult(handle));
+        await entry.sendInput(`${commandForDaytonaUser(command, args.runAs)}\n`);
+        return await formatPtyExecUpdate({
+            registry: this.ptyProcesses,
+            sessionId,
+            entry,
+            startTime: start,
+            yieldTimeMs: args.yieldTimeMs,
+            maxOutputTokens: args.maxOutputTokens,
+        });
+    }
+    async terminatePtyHandle(handle, providerSessionId) {
+        if (handle.kill) {
+            try {
+                await handle.kill();
+            }
+            catch {
+                // Ignore best-effort PTY cleanup failures.
+            }
+        }
+        else {
+            try {
+                await this.sandbox.process.killPtySession?.(handle.sessionId ?? providerSessionId);
+            }
+            catch {
+                // Ignore best-effort PTY cleanup failures.
+            }
+        }
+        try {
+            await handle.disconnect?.();
+        }
+        catch {
+            // Ignore best-effort PTY cleanup failures.
+        }
+    }
+    async viewImage(args) {
+        const bytes = args.runAs
+            ? await readRunAsRemoteFile({
+                providerName: 'DaytonaSandboxClient',
+                providerId: 'daytona',
+                path: await this.resolveRemotePath(args.path),
+                runAs: args.runAs,
+                runCommand: this.runAsCommandRunner.bind(this),
+            })
+            : await this.readFileBytes(args.path);
+        return imageOutputFromBytes(args.path, bytes);
+    }
+    async readFile(args) {
+        const bytes = args.runAs
+            ? await readRunAsRemoteFile({
+                providerName: 'DaytonaSandboxClient',
+                providerId: 'daytona',
+                path: await this.resolveRemotePath(args.path),
+                runAs: args.runAs,
+                runCommand: this.runAsCommandRunner.bind(this),
+            })
+            : await this.readFileBytes(args.path);
+        if (typeof args.maxBytes === 'number' && bytes.byteLength > args.maxBytes) {
+            return bytes.subarray(0, args.maxBytes);
+        }
+        return bytes;
+    }
+    async pathExists(path, runAs) {
+        const absolutePath = await this.resolveRemotePath(path);
+        if (!runAs) {
+            const result = await this.sandbox.process.executeCommand(`test -e ${shellQuote(absolutePath)}`, this.state.manifest.root, this.state.environment, 5);
+            return result.exitCode === 0;
+        }
+        return await runAsRemotePathExists(absolutePath, runAs, this.runAsCommandRunner.bind(this));
+    }
+    async running() {
+        try {
+            const result = await this.sandbox.process.executeCommand('true', this.state.manifest.root, this.state.environment, 5);
+            return result.exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async resolveExposedPort(port) {
+        const requestedPort = assertConfiguredExposedPort({
+            providerName: 'DaytonaSandboxClient',
+            port,
+            configuredPorts: this.state.configuredExposedPorts,
+        });
+        const cached = getUsableDaytonaCachedExposedPortEndpoint(this.state, requestedPort);
+        if (cached) {
+            return cached;
+        }
+        const preview = await this.createSignedPreviewUrl(requestedPort);
+        const url = typeof preview === 'string' ? preview : preview.url;
+        if (typeof url !== 'string') {
+            throw new SandboxProviderError('DaytonaSandboxClient exposed port preview did not include a URL.', {
+                provider: 'daytona',
+                port: requestedPort,
+            });
+        }
+        return recordResolvedExposedPortEndpoint(this.state, requestedPort, withDaytonaPreviewExpiration(parseExposedPortEndpoint(url, {
+            providerName: 'DaytonaSandboxClient',
+            source: 'preview URL',
+        }), this.state.exposedPortUrlTtlS));
+    }
+    async materializeEntry(args) {
+        assertSandboxEntryMetadataSupported('DaytonaSandboxClient', args.path, args.entry, MOUNT_MANIFEST_METADATA_SUPPORT);
+        await applyLocalSourceManifestEntryToState(this.state, args.path, args.entry, 'daytona', this.writer(), this.remotePathResolver, this.manifestMaterializationOptions(args.runAs));
+    }
+    async applyManifest(manifest, runAs) {
+        const resolvedManifest = resolveManifestRoot(manifest);
+        if (resolvedManifest.root !== this.state.manifest.root) {
+            throw new UserError('DaytonaSandboxClient cannot apply a manifest with a different root than the active session. Create or resume a session with the desired root instead.');
+        }
+        assertSandboxManifestMetadataSupported('DaytonaSandboxClient', resolvedManifest, MOUNT_MANIFEST_METADATA_SUPPORT);
+        await applyLocalSourceManifestToState(this.state, resolvedManifest, 'daytona', this.writer(), this.remotePathResolver, this.manifestMaterializationOptions(runAs));
+    }
+    async materializeInitialManifest(manifest) {
+        await materializeLocalSourceManifest(this.writer(), manifest, 'daytona', this.remotePathResolver, this.manifestMaterializationOptions());
+    }
+    async rematerializeMountEntries() {
+        const targets = [];
+        for (const target of this.state.manifest.mountTargetsForMaterialization()) {
+            targets.push({
+                ...target,
+                resolvedMountPath: await this.resolveMountEntryPath(target.mountPath, target.entry),
+            });
+        }
+        for (const { resolvedMountPath } of [...targets].reverse()) {
+            await this.unmountMountPath(resolvedMountPath);
+        }
+        this.activeMountPaths.clear();
+        for (const { mountPath, entry } of targets) {
+            await this.materializeMountEntry(mountPath, entry);
+        }
+    }
+    async prepareWorkspaceRoot() {
+        const root = this.state.manifest.root;
+        const result = await this.sandbox.process.executeCommand(`mkdir -p -- ${shellQuote(root)}`, '/', this.state.environment);
+        if (result.exitCode !== 0) {
+            throw new SandboxProviderError('DaytonaSandboxClient failed to prepare the workspace root.', {
+                provider: 'daytona',
+                operation: 'prepare workspace root',
+                sandboxId: this.state.sandboxId,
+                root,
+                stdout: result.artifacts?.stdout ?? result.result ?? '',
+            });
+        }
+    }
+    async persistWorkspace() {
+        assertTarWorkspacePersistence('DaytonaSandboxClient', 'tar');
+        return await persistRemoteWorkspaceTar({
+            providerName: 'DaytonaSandboxClient',
+            manifest: this.state.manifest,
+            io: this.archiveIo(),
+        });
+    }
+    async hydrateWorkspace(data) {
+        assertTarWorkspacePersistence('DaytonaSandboxClient', 'tar');
+        await hydrateRemoteWorkspaceTar({
+            providerName: 'DaytonaSandboxClient',
+            manifest: this.state.manifest,
+            io: this.archiveIo(),
+            data,
+        });
+    }
+    async close() {
+        if (this.state.pauseOnExit) {
+            await this.stopOnce();
+            return;
+        }
+        await this.deleteOnce();
+    }
+    async shutdown() {
+        await this.close();
+    }
+    async delete() {
+        await this.deleteOnce();
+    }
+    async stopOnce() {
+        this.stopPromise ??= (async () => {
+            await this.ptyProcesses.terminateAll();
+            await withSandboxSpan('sandbox.stop', {
+                backend_id: 'daytona',
+                sandbox_id: this.state.sandboxId,
+            }, async () => {
+                await this.sandbox.stop();
+            });
+        })();
+        await this.stopPromise;
+    }
+    async deleteOnce() {
+        this.deletePromise ??= (async () => {
+            await this.ptyProcesses.terminateAll();
+            await withSandboxSpan('sandbox.shutdown', {
+                backend_id: 'daytona',
+                sandbox_id: this.state.sandboxId,
+            }, async () => {
+                await this.unmountActiveMounts();
+                await deleteDaytonaSandboxWithRetry(async () => {
+                    await this.sandbox.delete();
+                });
+            });
+        })();
+        await this.deletePromise;
+    }
+    writer() {
+        return {
+            mkdir: async (path) => {
+                await this.sandbox.fs.createFolder(path, '755');
+            },
+            writeFile: async (path, content) => {
+                await this.ensureParentDir(path);
+                await this.sandbox.fs.uploadFile(Buffer.from(content), path);
+            },
+        };
+    }
+    manifestMaterializationOptions(runAs) {
+        return manifestMaterializationOptionsWithRunAs({
+            providerName: 'DaytonaSandboxClient',
+            providerId: 'daytona',
+            runAs,
+            runCommand: this.runAsCommandRunner.bind(this),
+            options: {
+                materializeMount: this.materializeMountEntry.bind(this),
+                concurrencyLimits: this.concurrencyLimits,
+            },
+            support: MOUNT_MANIFEST_METADATA_SUPPORT,
+        });
+    }
+    async materializeMountEntry(absolutePath, entry) {
+        if (!isDaytonaCloudBucketMountEntry(entry)) {
+            throw new SandboxUnsupportedFeatureError('DaytonaSandboxClient only supports DaytonaCloudBucketMountStrategy mount entries.', {
+                provider: 'daytona',
+                feature: 'entry.mountStrategy',
+                path: absolutePath,
+                mountType: entry.type,
+                strategyType: entry.mountStrategy?.type,
+            });
+        }
+        const mountPath = await this.resolveMountEntryPath(absolutePath, entry);
+        await mountRcloneCloudBucket({
+            providerName: 'DaytonaSandboxClient',
+            providerId: 'daytona',
+            strategyType: 'daytona_cloud_bucket',
+            entry,
+            mountPath,
+            pattern: rclonePatternFromMountStrategy(entry.mountStrategy),
+            runCommand: this.mountCommandRunner(),
+            writeFile: async (path, content) => {
+                await this.ensureParentDir(path);
+                await this.sandbox.fs.uploadFile(Buffer.from(content), path);
+            },
+            packageManagers: ['apt', 'apk'],
+        });
+        this.activeMountPaths.add(mountPath);
+    }
+    async unmountActiveMounts() {
+        for (const mountPath of [...this.activeMountPaths].reverse()) {
+            await this.unmountMountPath(mountPath);
+        }
+    }
+    async unmountMountPath(mountPath) {
+        await unmountRcloneMount({
+            providerName: 'DaytonaSandboxClient',
+            providerId: 'daytona',
+            mountPath,
+            runCommand: this.mountCommandRunner(),
+        }).catch(() => { });
+        this.activeMountPaths.delete(mountPath);
+    }
+    async resolveMountEntryPath(absolutePath, entry) {
+        return await this.resolveRemotePath(entry.mountPath ?? absolutePath, {
+            forWrite: true,
+        });
+    }
+    mountCommandRunner() {
+        return async (command, options = {}) => {
+            const commandToRun = commandForDaytonaUser(command, options.user);
+            const result = await this.sandbox.process.executeCommand(commandToRun, this.state.manifest.root, this.state.environment, options.timeoutMs ? Math.ceil(options.timeoutMs / 1000) : undefined);
+            return {
+                status: result.exitCode,
+                stdout: result.artifacts?.stdout ?? result.result ?? '',
+                stderr: '',
+            };
+        };
+    }
+    async runAsCommandRunner(command, options = {}) {
+        const result = await this.sandbox.process.executeCommand(commandForDaytonaUser(command, options.runAs), this.state.manifest.root, this.state.environment, this.state.timeoutSec);
+        return {
+            status: result.exitCode,
+            stdout: result.artifacts?.stdout ?? result.result ?? '',
+            stderr: '',
+        };
+    }
+    archiveIo() {
+        return {
+            runCommand: async (command) => {
+                const result = await this.sandbox.process.executeCommand(command, this.state.manifest.root, this.state.environment, this.state.timeoutSec);
+                return {
+                    status: result.exitCode,
+                    stdout: result.artifacts?.stdout ?? result.result ?? '',
+                    stderr: '',
+                };
+            },
+            readFile: async (path) => Uint8Array.from(await this.sandbox.fs.downloadFile(path)),
+            writeFile: async (path, content) => {
+                await this.ensureParentDir(path);
+                await this.sandbox.fs.uploadFile(Buffer.from(content), path);
+            },
+            mkdir: async (path) => {
+                await this.sandbox.fs.createFolder(path, '755');
+            },
+        };
+    }
+    async readFileBytes(path) {
+        const absolutePath = this.resolveEditorPath(path);
+        const output = await this.runEditorFileCommand([
+            'set -eu',
+            `root=${shellQuote(this.state.manifest.root)}`,
+            `path=${shellQuote(absolutePath)}`,
+            'resolved_root=$(realpath -m -- "$root")',
+            'resolved=$(readlink -f -- "$path")',
+            'case "$resolved" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved" >&2; exit 111 ;; esac',
+            '[ -f "$resolved" ] || { printf "not a regular file: %s\\n" "$resolved" >&2; exit 112; }',
+            'exec 3< "$resolved"',
+            'resolved=$(readlink -f "/proc/$$/fd/3")',
+            'case "$resolved" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved" >&2; exit 111 ;; esac',
+            'base64 <&3',
+        ].join('\n'));
+        return Buffer.from(output.replace(/\s+/gu, ''), 'base64');
+    }
+    async readEditorText(path) {
+        return new TextDecoder().decode(await this.readFileBytes(path));
+    }
+    async mkdirEditorPath(path) {
+        const absolutePath = this.resolveEditorPath(path, { forWrite: true });
+        await this.runEditorFileCommand([
+            'set -eu',
+            `root=${shellQuote(this.state.manifest.root)}`,
+            `path=${shellQuote(absolutePath)}`,
+            'resolved_root=$(realpath -m -- "$root")',
+            'resolved_path=$(realpath -m -- "$path")',
+            'case "$resolved_path" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved_path" >&2; exit 111 ;; esac',
+            'mkdir -p -- "$resolved_path"',
+            'resolved_created=$(realpath -m -- "$resolved_path")',
+            'case "$resolved_created" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved_created" >&2; exit 111 ;; esac',
+            '[ -d "$resolved_created" ] || { printf "not a directory: %s\\n" "$resolved_created" >&2; exit 112; }',
+        ].join('\n'));
+    }
+    async writeEditorText(path, content) {
+        const absolutePath = this.resolveEditorPath(path, { forWrite: true });
+        const encoded = Buffer.from(content, 'utf8').toString('base64');
+        await this.runEditorFileCommand([
+            'set -eu',
+            `root=${shellQuote(this.state.manifest.root)}`,
+            `path=${shellQuote(absolutePath)}`,
+            'resolved_root=$(realpath -m -- "$root")',
+            'parent=$(dirname -- "$path")',
+            'base=$(basename -- "$path")',
+            'resolved_parent=$(realpath -m -- "$parent")',
+            'case "$resolved_parent" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved_parent" >&2; exit 111 ;; esac',
+            'target="$resolved_parent/$base"',
+            'if [ -d "$target" ]; then printf "directory target: %s\\n" "$target" >&2; exit 112; fi',
+            'tmp=$(mktemp "$resolved_parent/.openai-agents-write.XXXXXX")',
+            'cleanup() { rm -f -- "$tmp"; }',
+            'trap cleanup EXIT HUP INT TERM',
+            'base64 -d > "$tmp" <<\'OPENAI_AGENTS_CONTENT\'',
+            encoded,
+            'OPENAI_AGENTS_CONTENT',
+            'chmod 644 "$tmp"',
+            'mv -f -- "$tmp" "$target"',
+            'trap - EXIT',
+        ].join('\n'));
+    }
+    async deleteEditorPath(path) {
+        const absolutePath = this.resolveEditorPath(path, { forWrite: true });
+        await this.runEditorFileCommand([
+            'set -eu',
+            `root=${shellQuote(this.state.manifest.root)}`,
+            `path=${shellQuote(absolutePath)}`,
+            'resolved_root=$(realpath -m -- "$root")',
+            'parent=$(dirname -- "$path")',
+            'base=$(basename -- "$path")',
+            'resolved_parent=$(realpath -m -- "$parent")',
+            'case "$resolved_parent" in "$resolved_root"|"$resolved_root"/*) ;; *) printf "workspace escape: %s\\n" "$resolved_parent" >&2; exit 111 ;; esac',
+            'rm -f -- "$resolved_parent/$base"',
+        ].join('\n'));
+    }
+    async runEditorFileCommand(command) {
+        const result = await this.sandbox.process.executeCommand(command, this.state.manifest.root, this.state.environment, this.state.timeoutSec);
+        if (result.exitCode !== 0) {
+            throw new UserError((result.artifacts?.stdout ||
+                result.result ||
+                'remote editor operation failed')
+                .trim()
+                .split(/\r?\n/u)
+                .join('; '));
+        }
+        return result.artifacts?.stdout ?? result.result ?? '';
+    }
+    resolveEditorPath(path, options = {}) {
+        return resolveSandboxAbsolutePath(this.state.manifest.root, path, options);
+    }
+    async ensureParentDir(path) {
+        const parent = posixDirname(path);
+        if (parent !== '.' && parent !== '/') {
+            await this.sandbox.fs.createFolder(parent, '755');
+        }
+    }
+    async resolveRemotePath(path, options = {}) {
+        return await validateRemoteSandboxPathForManifest({
+            manifest: this.state.manifest,
+            path,
+            options,
+            runCommand: async (command) => {
+                const result = await this.sandbox.process.executeCommand(command, this.state.manifest.root, this.state.environment);
+                return {
+                    status: result.exitCode,
+                    stdout: result.artifacts?.stdout ?? result.result ?? '',
+                    stderr: '',
+                };
+            },
+        });
+    }
+    async createSignedPreviewUrl(port) {
+        try {
+            if (this.sandbox.getSignedPreviewUrl) {
+                return await this.sandbox.getSignedPreviewUrl(port, this.state.exposedPortUrlTtlS);
+            }
+        }
+        catch (error) {
+            throw new SandboxProviderError(`DaytonaSandboxClient failed to resolve exposed port ${port}.`, {
+                provider: 'daytona',
+                port,
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+        throw new SandboxProviderError('DaytonaSandboxClient exposed port resolution requires a Daytona signed preview URL API.', {
+            provider: 'daytona',
+            port,
+        });
+    }
+}
+/**
+ * @see {@link https://www.daytona.io/docs/ | Daytona docs}.
+ * @see {@link https://www.daytona.io/docs/en/getting-started/ | Getting started}.
+ * @see {@link https://www.daytona.io/docs/en/typescript-sdk/sandbox/ | TypeScript SDK Sandbox reference}.
+ */
+export class DaytonaSandboxClient {
+    backendId = 'daytona';
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async create(args, manifestOptions) {
+        const createArgs = normalizeSandboxClientCreateArgs(args, manifestOptions);
+        assertCoreSnapshotUnsupported('DaytonaSandboxClient', createArgs.snapshot);
+        const manifest = createArgs.manifest;
+        const resolvedOptions = {
+            ...this.options,
+            ...createArgs.options,
+        };
+        const resolvedManifest = resolveManifestRoot(manifest);
+        assertSandboxManifestMetadataSupported('DaytonaSandboxClient', resolvedManifest, MOUNT_MANIFEST_METADATA_SUPPORT);
+        const client = await createDaytonaClient(resolvedOptions);
+        return await withSandboxSpan('sandbox.start', {
+            backend_id: this.backendId,
+        }, async () => {
+            const environment = await materializeEnvironment(resolvedManifest, resolvedOptions.env);
+            const sandbox = await withProviderError('DaytonaSandboxClient', 'daytona', 'create sandbox', async () => await client.create({
+                ...(resolvedOptions.sandboxSnapshotName
+                    ? { snapshot: resolvedOptions.sandboxSnapshotName }
+                    : { image: resolvedOptions.image ?? 'debian:12.9' }),
+                ...(!resolvedOptions.sandboxSnapshotName &&
+                    resolvedOptions.resources
+                    ? { resources: resolvedOptions.resources }
+                    : {}),
+                ...(resolvedOptions.name ? { name: resolvedOptions.name } : {}),
+                ...(typeof resolvedOptions.autoStopInterval === 'number'
+                    ? { autoStopInterval: resolvedOptions.autoStopInterval }
+                    : {}),
+                ...(typeof resolvedOptions.startTimeoutSec === 'number'
+                    ? { startTimeoutSec: resolvedOptions.startTimeoutSec }
+                    : {}),
+                ...(typeof resolvedOptions.timeoutSec === 'number'
+                    ? { timeoutSec: resolvedOptions.timeoutSec }
+                    : {}),
+                ...(resolvedOptions.exposedPorts
+                    ? { exposedPorts: resolvedOptions.exposedPorts }
+                    : {}),
+                ...(typeof resolvedOptions.exposedPortUrlTtlS === 'number'
+                    ? { exposedPortUrlTtlS: resolvedOptions.exposedPortUrlTtlS }
+                    : {}),
+                envVars: environment,
+            }, ...(typeof resolvedOptions.createTimeoutSec === 'number'
+                ? [{ timeout: resolvedOptions.createTimeoutSec }]
+                : [])), resolvedOptions.sandboxSnapshotName
+                ? { snapshot: resolvedOptions.sandboxSnapshotName }
+                : { image: resolvedOptions.image ?? 'debian:12.9' });
+            const session = new DaytonaSandboxSession({
+                sandbox,
+                concurrencyLimits: createArgs.concurrencyLimits,
+                state: {
+                    manifest: resolvedManifest,
+                    sandboxId: sandbox.id,
+                    image: resolvedOptions.image,
+                    resources: resolvedOptions.resources,
+                    pauseOnExit: resolvedOptions.pauseOnExit ?? false,
+                    createTimeoutSec: resolvedOptions.createTimeoutSec,
+                    startTimeoutSec: resolvedOptions.startTimeoutSec,
+                    timeoutSec: resolvedOptions.timeoutSec,
+                    sandboxSnapshotName: resolvedOptions.sandboxSnapshotName,
+                    configuredExposedPorts: resolvedOptions.exposedPorts,
+                    exposedPortUrlTtlS: resolvedOptions.exposedPortUrlTtlS,
+                    name: resolvedOptions.name,
+                    autoStopInterval: resolvedOptions.autoStopInterval,
+                    environment,
+                    apiKey: resolvedOptions.apiKey,
+                    apiUrl: resolvedOptions.apiUrl,
+                    target: resolvedOptions.target,
+                },
+            });
+            try {
+                await session.prepareWorkspaceRoot();
+                await session.materializeInitialManifest(resolvedManifest);
+            }
+            catch (error) {
+                session.state.pauseOnExit = false;
+                await closeRemoteSessionOnManifestError('Daytona', session, error);
+            }
+            return session;
+        });
+    }
+    async serializeSessionState(state) {
+        return serializeRemoteSandboxSessionState(state);
+    }
+    canPersistOwnedSessionState(state) {
+        return state.pauseOnExit;
+    }
+    async deserializeSessionState(state) {
+        const baseState = deserializeRemoteSandboxSessionStateValues(state, this.options.env);
+        return {
+            ...state,
+            ...baseState,
+            sandboxId: readString(state, 'sandboxId'),
+            pauseOnExit: Boolean(state.pauseOnExit),
+            image: readOptionalString(state, 'image'),
+            resources: readOptionalRecord(state.resources),
+            createTimeoutSec: readOptionalNumber(state, 'createTimeoutSec'),
+            startTimeoutSec: readOptionalNumber(state, 'startTimeoutSec'),
+            timeoutSec: readOptionalNumber(state, 'timeoutSec'),
+            sandboxSnapshotName: readOptionalString(state, 'sandboxSnapshotName'),
+            configuredExposedPorts: readOptionalNumberArray(state.configuredExposedPorts),
+            exposedPortUrlTtlS: readOptionalNumber(state, 'exposedPortUrlTtlS'),
+            name: readOptionalString(state, 'name'),
+            autoStopInterval: readOptionalNumber(state, 'autoStopInterval'),
+            apiKey: readOptionalString(state, 'apiKey'),
+            apiUrl: readOptionalString(state, 'apiUrl'),
+            target: readOptionalString(state, 'target'),
+        };
+    }
+    async resume(state) {
+        const client = await createDaytonaClient({
+            ...this.options,
+            apiKey: state.apiKey ?? this.options.apiKey,
+            apiUrl: state.apiUrl ?? this.options.apiUrl,
+            target: state.target ?? this.options.target,
+        });
+        let sandbox;
+        try {
+            sandbox = await client.get(state.sandboxId);
+            await sandbox.start(state.startTimeoutSec);
+        }
+        catch (error) {
+            assertResumeRecreateAllowed(error, {
+                providerName: 'DaytonaSandboxClient',
+                provider: 'daytona',
+                details: { sandboxId: state.sandboxId },
+            });
+            return await this.recreateFromPersistedState(client, state);
+        }
+        const session = new DaytonaSandboxSession({ state, sandbox });
+        await session.prepareWorkspaceRoot();
+        await session.rematerializeMountEntries();
+        return session;
+    }
+    async recreateFromPersistedState(client, state) {
+        const sandbox = await withProviderError('DaytonaSandboxClient', 'daytona', 'create sandbox', async () => await client.create({
+            ...(state.sandboxSnapshotName
+                ? { snapshot: state.sandboxSnapshotName }
+                : { image: state.image ?? 'debian:12.9' }),
+            ...(!state.sandboxSnapshotName && state.resources
+                ? { resources: state.resources }
+                : {}),
+            ...(state.name ? { name: state.name } : {}),
+            ...(typeof state.autoStopInterval === 'number'
+                ? { autoStopInterval: state.autoStopInterval }
+                : {}),
+            ...(typeof state.startTimeoutSec === 'number'
+                ? { startTimeoutSec: state.startTimeoutSec }
+                : {}),
+            ...(typeof state.timeoutSec === 'number'
+                ? { timeoutSec: state.timeoutSec }
+                : {}),
+            ...(state.configuredExposedPorts
+                ? { exposedPorts: state.configuredExposedPorts }
+                : {}),
+            ...(typeof state.exposedPortUrlTtlS === 'number'
+                ? { exposedPortUrlTtlS: state.exposedPortUrlTtlS }
+                : {}),
+            envVars: state.environment,
+        }, ...(typeof state.createTimeoutSec === 'number'
+            ? [{ timeout: state.createTimeoutSec }]
+            : [])), state.sandboxSnapshotName
+            ? { snapshot: state.sandboxSnapshotName }
+            : { image: state.image ?? 'debian:12.9' });
+        const nextState = {
+            ...state,
+            sandboxId: sandbox.id,
+            environment: { ...state.environment },
+        };
+        delete nextState.exposedPorts;
+        const session = new DaytonaSandboxSession({
+            sandbox,
+            state: nextState,
+        });
+        try {
+            await session.prepareWorkspaceRoot();
+            await session.materializeInitialManifest(state.manifest);
+        }
+        catch (error) {
+            session.state.pauseOnExit = false;
+            await closeRemoteSessionOnManifestError('Daytona', session, error);
+        }
+        return session;
+    }
+}
+function getUsableDaytonaCachedExposedPortEndpoint(state, requestedPort) {
+    const cached = getCachedExposedPortEndpoint(state, requestedPort);
+    if (!cached) {
+        return undefined;
+    }
+    const expiresAtMs = cached.daytonaExpiresAtMs;
+    return typeof expiresAtMs === 'number' &&
+        Number.isFinite(expiresAtMs) &&
+        expiresAtMs > Date.now()
+        ? cached
+        : undefined;
+}
+function withDaytonaPreviewExpiration(endpoint, ttlS) {
+    const resolvedTtlS = typeof ttlS === 'number' ? ttlS : DEFAULT_EXPOSED_PORT_URL_TTL_S;
+    if (!Number.isFinite(resolvedTtlS) || resolvedTtlS <= 0) {
+        return endpoint;
+    }
+    return {
+        ...endpoint,
+        daytonaExpiresAtMs: Date.now() + resolvedTtlS * 1000,
+    };
+}
+async function createDaytonaClient(options) {
+    try {
+        const { Daytona } = await import('@daytonaio/sdk');
+        return adaptDaytonaClient(new Daytona({
+            ...(options.apiKey ? { apiKey: options.apiKey } : {}),
+            ...(options.apiUrl ? { apiUrl: options.apiUrl } : {}),
+            ...(options.target ? { target: options.target } : {}),
+        }));
+    }
+    catch (error) {
+        throw new UserError(`Daytona sandbox support requires the optional \`@daytonaio/sdk\` package. Install it before using Daytona-backed sandbox examples. ${error.message}`);
+    }
+}
+function adaptDaytonaClient(client) {
+    return {
+        create: async (params, options) => adaptDaytonaSandbox(await client.create(params, options)),
+        get: async (idOrName) => adaptDaytonaSandbox(await client.get(idOrName)),
+    };
+}
+function adaptDaytonaSandbox(sandbox) {
+    return {
+        id: sandbox.id,
+        start: async (timeout) => await sandbox.start(timeout),
+        stop: async (timeout, force) => await sandbox.stop(timeout, force),
+        delete: async (timeout) => await sandbox.delete(timeout),
+        fs: {
+            createFolder: async (path, mode) => await sandbox.fs.createFolder(path, mode),
+            uploadFile: async (source, remotePath, timeout) => {
+                if (typeof source === 'string') {
+                    if (typeof timeout === 'number') {
+                        await sandbox.fs.uploadFile(source, remotePath, timeout);
+                    }
+                    else {
+                        await sandbox.fs.uploadFile(source, remotePath);
+                    }
+                    return;
+                }
+                if (typeof timeout === 'number') {
+                    await sandbox.fs.uploadFile(source, remotePath, timeout);
+                }
+                else {
+                    await sandbox.fs.uploadFile(source, remotePath);
+                }
+            },
+            downloadFile: async (remotePath, timeout) => await sandbox.fs.downloadFile(remotePath, timeout),
+            deleteFile: async (path, recursive) => await sandbox.fs.deleteFile(path, recursive),
+        },
+        process: {
+            executeCommand: async (command, cwd, env, timeout) => typeof timeout === 'number'
+                ? await sandbox.process.executeCommand(command, cwd, env, timeout)
+                : await sandbox.process.executeCommand(command, cwd, env),
+            ...(typeof sandbox.process.createPty === 'function'
+                ? {
+                    createPty: async (options) => await sandbox.process.createPty(options),
+                }
+                : {}),
+            ...(typeof sandbox.process.killPtySession === 'function'
+                ? {
+                    killPtySession: async (id) => await sandbox.process.killPtySession(id),
+                }
+                : {}),
+        },
+        getSignedPreviewUrl: async (port, expiresInSeconds) => await sandbox.getSignedPreviewUrl(port, expiresInSeconds),
+    };
+}
+function resolveManifestRoot(manifest) {
+    if (manifest.root === '/workspace') {
+        return cloneManifestWithRoot(manifest, DEFAULT_WORKSPACE_ROOT);
+    }
+    return manifest;
+}
+function commandForDaytonaUser(command, user) {
+    return sandboxUserShellCommand(command, user);
+}
+async function deleteDaytonaSandboxWithRetry(deleteSandbox) {
+    let attempt = 0;
+    while (true) {
+        try {
+            await deleteSandbox();
+            return;
+        }
+        catch (error) {
+            const delayMs = DAYTONA_DELETE_RETRY_DELAYS_MS[attempt];
+            if (!isDaytonaStateChangeInProgressError(error) ||
+                delayMs === undefined) {
+                throw error;
+            }
+            attempt += 1;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+}
+function isDaytonaStateChangeInProgressError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return false;
+    }
+    const record = error;
+    return (record.statusCode === 409 &&
+        error instanceof Error &&
+        /state change in progress/i.test(error.message));
+}
+function exitCodeFromDaytonaResult(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    return typeof record.exitCode === 'number' ? record.exitCode : undefined;
+}
+//# sourceMappingURL=sandbox.mjs.map