zidane 7.2.4 → 8.0.4

package/dist/daytona-DG3omipZ.js

@@ -0,0 +1,513 @@
+import { u as errorMessage } from "./errors-DKiMrOKq.js";
+import { r as createLogger, t as consoleSink } from "./logger-Gtqlayx8.js";
+import { t as TERMINAL_ENV, u as capBufferedExecOutput } from "./local-terminal-D8QThwo_.js";
+import { t as StreamQueue } from "./stream-queue-Cd9OJxl7.js";
+import { Buffer } from "node:buffer";
+//#region src/contexts/daytona-sdk.ts
+function resolveDaytonaEnv(optionEnv, perSpawnEnv) {
+	const merged = {
+		...optionEnv,
+		...perSpawnEnv
+	};
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function normalizeDaytonaExecResult(response) {
+	return {
+		stdout: response.stdout ?? response.artifacts?.stdout ?? response.result ?? response.output ?? "",
+		stderr: response.stderr ?? "",
+		exitCode: typeof response.exitCode === "number" ? response.exitCode : 0
+	};
+}
+//#endregion
+//#region src/contexts/daytona-stream.ts
+/** A `TerminalProcess` over a Daytona PTY session. Input is chained to keep keystroke order. */
+function daytonaTerminal(sandbox, id, pty) {
+	let input = Promise.resolve();
+	let killed = null;
+	return {
+		id,
+		reconnectable: sandbox.process.connectPty !== void 0,
+		write: (data) => {
+			input = input.then(() => pty.sendInput(data)).catch(() => {});
+		},
+		resize: (cols, rows) => {
+			pty.resize?.(cols, rows).catch(() => {});
+		},
+		kill: () => killed ??= (async () => {
+			await (sandbox.process.killPtySession?.(id) ?? pty.kill?.())?.catch(() => {});
+			await pty.disconnect().catch(() => {});
+		})(),
+		detach: () => pty.disconnect().then(() => {}, () => {}),
+		exited: pty.wait().then((result) => result?.exitCode ?? -1, () => -1)
+	};
+}
+function daytonaTerminalMethods(get) {
+	return {
+		/**
+		* A login shell in the sandbox through a Daytona PTY session. Sessions
+		* persist server-side after the websocket drops, which is what lets
+		* `reconnectTerminal` find them again by id, and why `kill` must end the
+		* session rather than just disconnect.
+		*/
+		async openTerminal(sandboxId, options) {
+			const { sandbox, env } = get(sandboxId);
+			if (!sandbox.process.createPty) throw new Error("Daytona SDK is too old: `process.createPty` is required for terminals.");
+			const id = `zidane-tty-${Math.random().toString(36).slice(2, 10)}`;
+			const pty = await sandbox.process.createPty({
+				id,
+				...options.cwd ? { cwd: options.cwd } : {},
+				envs: resolveDaytonaEnv(env, {
+					...options.env,
+					...TERMINAL_ENV
+				}) ?? {},
+				cols: options.cols,
+				rows: options.rows,
+				onData: options.onData
+			});
+			await pty.waitForConnection();
+			return daytonaTerminal(sandbox, id, pty);
+		},
+		async reconnectTerminal(sandboxId, id, options) {
+			const { sandbox } = get(sandboxId);
+			if (!sandbox.process.connectPty) return null;
+			const pty = await sandbox.process.connectPty(id, { onData: options.onData }).catch(() => null);
+			if (!pty) return null;
+			await pty.waitForConnection();
+			const terminal = daytonaTerminal(sandbox, id, pty);
+			terminal.resize(options.cols, options.rows);
+			return terminal;
+		}
+	};
+}
+function daytonaStreamMethods(get, logger) {
+	return { 
+	/**
+	* Live bidirectional stream — see `ExecutionContext.execStream`.
+	*
+	* PTY-backed, and not by preference: Daytona's process + session API
+	* exposes no stdin at all (sessions are fire-and-forget with log
+	* streaming), so a pseudo-terminal is the only interactive channel the
+	* platform offers. That forces three mitigations, all in the launch
+	* wrapper below, because a PTY is a terminal and a protocol stream is
+	* not:
+	*
+	*  1. `stty -echo` — a terminal echoes everything written to stdin back
+	*     onto stdout. Without this the caller reads its own requests back
+	*     as if they were responses.
+	*  2. `stty raw` — canonical mode rewrites `\n`→`\r\n` and caps a line
+	*     at ~4096 bytes. Protocol frames routinely exceed that and would
+	*     be silently truncated mid-message.
+	*  3. `2><file>` — a PTY has ONE stream, so the child's stderr would
+	*     otherwise interleave into the protocol data and corrupt framing.
+	*     It is redirected to a file inside the sandbox and surfaced on the
+	*     returned handle by polling that file through the exec API.
+	*
+	* The mitigations must run before the child's first byte — but the
+	* launch line ITSELF is typed into a canonical-mode terminal, so it is
+	* echoed once (a short non-JSON line the transport's tolerant framing
+	* discards) and subject to the ~4096-byte line cap. That is why the
+	* real command lives in an uploaded script and the typed line stays
+	* short and constant: a long command line would be truncated before
+	* `stty` ever ran. The script also restores `sh` compound-command
+	* semantics that a bare `exec <command>` would break.
+	*/
+async execStream(sandboxId, command, opts) {
+		const { sandbox, env } = get(sandboxId);
+		if (!sandbox.process.createPty) throw new Error("Daytona SDK is too old: `process.createPty` is required for execStream (used to run stdio MCP servers inside the sandbox).");
+		opts?.signal?.throwIfAborted();
+		const token = Math.random().toString(36).slice(2, 10);
+		const stderrPath = `/tmp/.zidane-stream-${token}.err`;
+		const scriptPath = `/tmp/.zidane-stream-${token}.sh`;
+		await sandbox.fs.uploadFile(Buffer.from(`exec 2>${stderrPath}\n${command}\n`), scriptPath);
+		const warnBacklog = (which) => (bytes) => logger.warn("execStream consumer is not draining output", {
+			sandboxId,
+			stream: which,
+			bufferedBytes: bytes
+		});
+		const stdout = new StreamQueue(warnBacklog("stdout"));
+		const stderr = new StreamQueue(warnBacklog("stderr"));
+		const sentinel = `Z-${token}-READY`;
+		let gateOpen = false;
+		let gateBuffer = "";
+		let openGate = () => {};
+		const gateReady = new Promise((r) => {
+			openGate = r;
+		});
+		const pty = await sandbox.process.createPty({
+			id: `zidane-stream-${token}`,
+			...opts?.cwd ? { cwd: opts.cwd } : {},
+			envs: resolveDaytonaEnv(env, opts?.env) ?? {},
+			onData: (data) => {
+				if (gateOpen) {
+					stdout.push(data);
+					return;
+				}
+				gateBuffer += Buffer.from(data).toString("utf8");
+				const at = gateBuffer.indexOf(sentinel);
+				if (at === -1) {
+					if (gateBuffer.length > 65536) gateBuffer = gateBuffer.slice(-1024);
+					return;
+				}
+				gateOpen = true;
+				openGate();
+				const rest = gateBuffer.slice(at + sentinel.length).replace(/^\r?\n/, "");
+				gateBuffer = "";
+				if (rest.length > 0) stdout.push(new TextEncoder().encode(rest));
+			}
+		});
+		await pty.waitForConnection();
+		await pty.sendInput(`stty raw -echo; printf 'Z-%s-READY\\n' ${token}; exec sh ${scriptPath}\n`);
+		let gateTimer;
+		await Promise.race([gateReady, new Promise((r) => {
+			gateTimer = setTimeout(r, 3e4);
+		})]);
+		clearTimeout(gateTimer);
+		if (!gateOpen) {
+			await (pty.kill?.() ?? Promise.resolve()).catch(() => {});
+			await pty.disconnect().catch(() => {});
+			await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {});
+			throw new Error(`Daytona execStream: PTY did not reach the ready sentinel within 30s (sandbox ${sandboxId}). The login shell may not have started.`);
+		}
+		let stderrOffset = 0;
+		let torndown = false;
+		const eofMark = `ZEOF-${token}:`;
+		const drainStderr = async () => {
+			try {
+				const res = normalizeDaytonaExecResult(await sandbox.process.executeCommand(`tail -c +${stderrOffset + 1} ${stderrPath} 2>/dev/null; printf '${eofMark}%s' "$(wc -c < ${stderrPath} 2>/dev/null || echo 0)"`));
+				const at = res.stdout.lastIndexOf(eofMark);
+				if (at === -1) return;
+				const content = res.stdout.slice(0, at);
+				const size = Number.parseInt(res.stdout.slice(at + eofMark.length).trim(), 10);
+				if (content.length > 0) stderr.push(new TextEncoder().encode(content));
+				if (Number.isFinite(size) && size > stderrOffset) stderrOffset = size;
+			} catch {}
+		};
+		const stderrTimer = setInterval(() => {
+			drainStderr();
+		}, 2e3);
+		stderrTimer.unref?.();
+		const teardown = async () => {
+			if (torndown) return;
+			torndown = true;
+			clearInterval(stderrTimer);
+			await drainStderr();
+			await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {});
+			stdout.close();
+			stderr.close();
+		};
+		const exited = pty.wait().then((result) => result?.exitCode ?? 0).catch(() => 137).finally(teardown);
+		const kill = async () => {
+			await (pty.kill?.() ?? Promise.resolve()).catch(() => {});
+			await pty.disconnect().catch(() => {});
+			await teardown();
+		};
+		if (opts?.signal) {
+			if (opts.signal.aborted) kill();
+			else {
+				const onAbort = () => {
+					kill();
+				};
+				const detach = () => opts.signal.removeEventListener("abort", onAbort);
+				opts.signal.addEventListener("abort", onAbort, { once: true });
+				exited.then(detach, detach);
+			}
+		}
+		return {
+			pid: pty.pid ?? -1,
+			stdout,
+			stderr,
+			write: async (data) => {
+				await pty.sendInput(data);
+			},
+			kill,
+			exited
+		};
+	} };
+}
+//#endregion
+//#region src/contexts/daytona.ts
+/** Per-probe timeout for the readiness `true` command. */
+const READINESS_PROBE_TIMEOUT_SECONDS = 5;
+/** Pause between readiness probes while the sandbox is still warming up. */
+const READINESS_BACKOFF_MS = 250;
+/** Setup scripts commonly install dependencies, so give them a generous cap. */
+const PREGAME_TIMEOUT_SECONDS = 1800;
+function capExecResult(result) {
+	return {
+		...capBufferedExecOutput(result.stdout, result.stderr),
+		exitCode: result.exitCode
+	};
+}
+function normalizeDaytonaExecError(error) {
+	const err = error;
+	if (typeof err.exitCode === "number") return {
+		stdout: typeof err.stdout === "string" ? err.stdout : typeof err.result === "string" ? err.result : typeof err.output === "string" ? err.output : "",
+		stderr: typeof err.stderr === "string" ? err.stderr : typeof err.message === "string" ? err.message : "",
+		exitCode: err.exitCode
+	};
+	return {
+		stdout: "",
+		stderr: error instanceof Error ? error.message : String(error),
+		exitCode: 124
+	};
+}
+function toClientConfig(apiKey, apiUrl, target) {
+	const config = {};
+	if (apiKey !== void 0) config.apiKey = apiKey;
+	if (apiUrl !== void 0) config.apiUrl = apiUrl;
+	if (target !== void 0) config.target = target;
+	return Object.keys(config).length > 0 ? config : void 0;
+}
+function takeString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function resolveDaytonaCreateParams(sandboxConfig, options, envVars) {
+	const reserved = /* @__PURE__ */ new Set([
+		"provider",
+		"apiKey",
+		"apiUrl",
+		"target",
+		"sandboxId"
+	]);
+	const params = {};
+	for (const [key, value] of Object.entries(sandboxConfig)) if (!reserved.has(key) && value !== void 0) params[key] = value;
+	const language = takeString(sandboxConfig.language) ?? options.language;
+	const snapshot = takeString(sandboxConfig.snapshot) ?? options.snapshot;
+	const image = sandboxConfig.image ?? options.image;
+	const resources = sandboxConfig.resources ?? options.resources;
+	const configEnvVars = sandboxConfig.envVars;
+	const mergedEnvVars = resolveDaytonaEnv(envVars, configEnvVars);
+	if (language !== void 0) params.language = language;
+	if (snapshot !== void 0) params.snapshot = snapshot;
+	if (image !== void 0) params.image = image;
+	if (resources !== void 0) params.resources = resources;
+	if (mergedEnvVars !== void 0) params.envVars = mergedEnvVars;
+	return Object.keys(params).length > 0 ? params : void 0;
+}
+async function waitForDaytonaReady(sandbox, logger, opts) {
+	if (opts.timeoutSeconds <= 0) return;
+	const now = opts.now ?? Date.now;
+	const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const start = now();
+	const deadline = start + opts.timeoutSeconds * 1e3;
+	logger.info("waiting for Daytona sandbox to initialize", { sandboxId: sandbox.id });
+	while (true) try {
+		await sandbox.process.executeCommand("true", void 0, void 0, READINESS_PROBE_TIMEOUT_SECONDS);
+		logger.info("Daytona sandbox ready", {
+			sandboxId: sandbox.id,
+			elapsedMs: now() - start
+		});
+		return;
+	} catch {
+		if (now() >= deadline) {
+			await opts.cleanupOnTimeout?.().catch(() => {});
+			throw new Error(`Daytona sandbox ${sandbox.id} did not become ready within ${opts.timeoutSeconds}s`);
+		}
+		await sleep(READINESS_BACKOFF_MS);
+	}
+}
+async function runDaytonaPregame(sandbox, logger, opts) {
+	const path = `/tmp/${opts.name}`;
+	logger.info("running Daytona pregame script", {
+		sandboxId: sandbox.id,
+		path
+	});
+	await sandbox.fs.uploadFile(Buffer.from(opts.content), path);
+	const quoted = JSON.stringify(path);
+	let result;
+	try {
+		result = normalizeDaytonaExecResult(await sandbox.process.executeCommand(`chmod +x ${quoted} && ${quoted}`, opts.cwd, opts.envVars, PREGAME_TIMEOUT_SECONDS));
+	} catch (err) {
+		result = normalizeDaytonaExecError(err);
+	}
+	if (result.exitCode !== 0) {
+		logger.error("Daytona pregame script failed", {
+			sandboxId: sandbox.id,
+			exitCode: result.exitCode,
+			stdout: result.stdout,
+			stderr: result.stderr
+		});
+		throw new Error(`Daytona pregame script ${opts.name} failed with exit code ${result.exitCode}`);
+	}
+	logger.info("Daytona pregame ready", {
+		sandboxId: sandbox.id,
+		stdout: result.stdout,
+		stderr: result.stderr
+	});
+}
+function createDaytonaProvider(options = {}) {
+	const live = /* @__PURE__ */ new Map();
+	const logger = options.logger ?? createLogger(consoleSink());
+	const readinessTimeoutSeconds = options.readinessTimeoutSeconds ?? 60;
+	async function loadSdk() {
+		try {
+			return (await import("@daytona/sdk")).Daytona;
+		} catch (err) {
+			const message = errorMessage(err);
+			const notInstalled = /cannot find (?:module|package)|module not found|failed to resolve/i.test(message);
+			throw new Error(notInstalled ? "@daytona/sdk is required for the Daytona sandbox provider. Install it with: bun add @daytona/sdk" : `@daytona/sdk is installed but failed to load: ${message}. If this mentions tslib, pin it with a root override: "overrides": { "tslib": "^2.8.1" }. See docs/RESTATE.md.`, { cause: err });
+		}
+	}
+	function get(sandboxId) {
+		const entry = live.get(sandboxId);
+		if (!entry) throw new Error(`Daytona sandbox ${sandboxId} is not tracked by this provider`);
+		return entry;
+	}
+	async function deleteOwnedSandbox(sandbox) {
+		try {
+			await sandbox.delete();
+		} catch {}
+	}
+	async function stopOwnedSandbox(sandbox) {
+		if (!sandbox.stop) {
+			logger.error("cannot stop Daytona sandbox: this @daytona/sdk install exposes no stop() method; leaving it running", { sandboxId: sandbox.id });
+			return;
+		}
+		try {
+			await sandbox.stop();
+			logger.info("stopped Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)", { sandboxId: sandbox.id });
+		} catch (err) {
+			logger.error("failed to stop Daytona sandbox; it will run until Daytona lifecycle policy stops it", {
+				sandboxId: sandbox.id,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	async function archiveOwnedSandbox(sandbox) {
+		if (!sandbox.stop || !sandbox.archive) {
+			logger.error("cannot archive Daytona sandbox: this @daytona/sdk install exposes no stop() and archive() pair; leaving it running", { sandboxId: sandbox.id });
+			return;
+		}
+		try {
+			await sandbox.stop();
+			await sandbox.archive();
+			logger.info("archived Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)", { sandboxId: sandbox.id });
+		} catch (err) {
+			logger.error("failed to archive Daytona sandbox; it will run until Daytona lifecycle policy stops it", {
+				sandboxId: sandbox.id,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	async function startAttachedSandboxIfNeeded(sandbox) {
+		if (sandbox.state !== "stopped" && sandbox.state !== "archived") return;
+		if (!sandbox.start) {
+			logger.error("cannot start Daytona sandbox before attach readiness probe: this @daytona/sdk install exposes no start() method", {
+				sandboxId: sandbox.id,
+				state: sandbox.state
+			});
+			return;
+		}
+		logger.info("starting Daytona sandbox before attach readiness probe", {
+			sandboxId: sandbox.id,
+			state: sandbox.state
+		});
+		await sandbox.start(readinessTimeoutSeconds > 0 ? readinessTimeoutSeconds : void 0);
+	}
+	const streamM = daytonaStreamMethods(get, logger);
+	const termM = daytonaTerminalMethods(get);
+	return {
+		name: "daytona",
+		async spawn(config = {}) {
+			const Daytona = await loadSdk();
+			const sb = config.sandbox ?? {};
+			const apiKey = takeString(sb.apiKey) ?? options.apiKey;
+			const apiUrl = takeString(sb.apiUrl) ?? options.apiUrl;
+			const target = takeString(sb.target) ?? options.target;
+			const connectId = takeString(sb.sandboxId) ?? options.sandboxId;
+			const snapshot = takeString(sb.snapshot) ?? options.snapshot;
+			const envVars = resolveDaytonaEnv(options.env, config.env);
+			const daytona = new Daytona(toClientConfig(apiKey, apiUrl, target));
+			let attached = connectId !== void 0;
+			let sandbox = connectId !== void 0 ? await daytona.get(connectId) : await daytona.create(resolveDaytonaCreateParams(sb, options, envVars));
+			if (attached && snapshot !== void 0 && sandbox.snapshot !== snapshot) {
+				logger.info("recreating Daytona sandbox: snapshot changed", {
+					sandboxId: sandbox.id,
+					previousSnapshot: sandbox.snapshot,
+					newSnapshot: snapshot
+				});
+				await deleteOwnedSandbox(sandbox);
+				attached = false;
+				sandbox = await daytona.create(resolveDaytonaCreateParams(sb, options, envVars));
+			}
+			const owned = !attached || options.ownAttached === true;
+			if (attached) await startAttachedSandboxIfNeeded(sandbox);
+			live.set(sandbox.id, {
+				sandbox,
+				env: envVars,
+				owned
+			});
+			try {
+				await waitForDaytonaReady(sandbox, logger, {
+					timeoutSeconds: readinessTimeoutSeconds,
+					...!attached ? { cleanupOnTimeout: () => deleteOwnedSandbox(sandbox) } : {}
+				});
+			} catch (err) {
+				live.delete(sandbox.id);
+				throw err;
+			}
+			const requestedCwd = config.cwd ?? options.cwd;
+			let cwd;
+			if (requestedCwd) {
+				cwd = requestedCwd;
+				await sandbox.process.executeCommand(`mkdir -p ${JSON.stringify(cwd)}`).catch(() => {});
+			} else if (sandbox.getWorkDir) {
+				cwd = await sandbox.getWorkDir().catch(() => "");
+				if (!cwd) cwd = await sandbox.process.executeCommand("pwd").then((r) => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => "") || "/home/daytona";
+			} else cwd = await sandbox.process.executeCommand("pwd").then((r) => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => "") || "/home/daytona";
+			if (options.pregame) try {
+				await runDaytonaPregame(sandbox, logger, {
+					name: options.pregame.name,
+					content: options.pregame.content,
+					cwd,
+					envVars
+				});
+			} catch (err) {
+				if (!attached) await deleteOwnedSandbox(sandbox);
+				live.delete(sandbox.id);
+				throw err;
+			}
+			return {
+				id: sandbox.id,
+				cwd
+			};
+		},
+		openTerminal: termM.openTerminal,
+		reconnectTerminal: termM.reconnectTerminal,
+		async exec(sandboxId, command, opts) {
+			const { sandbox, env } = get(sandboxId);
+			const timeoutSeconds = opts?.timeout ?? 30;
+			try {
+				return capExecResult(normalizeDaytonaExecResult(await sandbox.process.executeCommand(command, opts?.cwd, resolveDaytonaEnv(env, opts?.env), timeoutSeconds > 0 ? timeoutSeconds : void 0)));
+			} catch (err) {
+				return capExecResult(normalizeDaytonaExecError(err));
+			}
+		},
+		execStream: streamM.execStream,
+		async readFile(sandboxId, path) {
+			return (await get(sandboxId).sandbox.fs.downloadFile(path)).toString("utf8");
+		},
+		async writeFile(sandboxId, path, content, encoding = "utf-8") {
+			const data = typeof content === "string" ? Buffer.from(content, encoding) : content;
+			await get(sandboxId).sandbox.fs.uploadFile(data, path);
+		},
+		async listFiles(sandboxId, path) {
+			return (await get(sandboxId).sandbox.fs.listFiles(path)).map((e) => e.isDir ? `${e.name}/` : e.name);
+		},
+		async destroy(sandboxId) {
+			const entry = live.get(sandboxId);
+			if (!entry) return;
+			if (entry.owned) {
+				const action = options.onDestroy ?? "delete";
+				if (action === "stop" || action === "pause") await stopOwnedSandbox(entry.sandbox);
+				else if (action === "archive") await archiveOwnedSandbox(entry.sandbox);
+				else if (action === "delete" || action === "kill") await deleteOwnedSandbox(entry.sandbox);
+			}
+			live.delete(sandboxId);
+		}
+	};
+}
+//#endregion
+export { normalizeDaytonaExecResult as a, waitForDaytonaReady as i, resolveDaytonaCreateParams as n, resolveDaytonaEnv as o, runDaytonaPregame as r, createDaytonaProvider as t };
+
+//# sourceMappingURL=daytona-DG3omipZ.js.map

package/dist/daytona-DG3omipZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daytona-DG3omipZ.js","names":[],"sources":["../src/contexts/daytona-sdk.ts","../src/contexts/daytona-stream.ts","../src/contexts/daytona.ts"],"sourcesContent":["/**\n * Structural `@daytona/sdk` views + env/result helpers shared by the Daytona\n * provider modules. Internal module.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ExecResult } from './types'\n\n// ---------------------------------------------------------------------------\n// Minimal structural views of the `@daytona/sdk` surface we touch. Declared\n// locally so zidane typechecks without the optional peer dependency installed.\n// ---------------------------------------------------------------------------\n\nexport interface DaytonaExecuteResponse {\n  exitCode?: number | null\n  result?: string | null\n  output?: string | null\n  stdout?: string | null\n  stderr?: string | null\n  artifacts?: { stdout?: string | null }\n}\n\nexport interface DaytonaFileEntry {\n  name: string\n  /** Present in the Daytona SDK's FileInfo; used for the `/` dir suffix. */\n  isDir?: boolean\n}\n\n/**\n * Structural subset of Daytona's `PtyHandle`.\n *\n * Daytona's process/session API has NO stdin channel at all — sessions are\n * fire-and-forget with log streaming — so a PTY is the only way to reach a\n * long-lived process interactively. See the `execStream` implementation for\n * what that costs.\n */\nexport interface DaytonaPtyHandle {\n  pid?: number\n  waitForConnection: () => Promise<unknown>\n  sendInput: (data: string | Uint8Array) => Promise<unknown>\n  wait: () => Promise<{ exitCode?: number }>\n  kill?: () => Promise<unknown>\n  disconnect: () => Promise<unknown>\n  /** Used by terminals only. */\n  resize?: (cols: number, rows: number) => Promise<unknown>\n}\n\nexport interface DaytonaSandbox {\n  id: string\n  state?: string\n  snapshot?: string\n  process: {\n    executeCommand: (command: string, cwd?: string, env?: Record<string, string>, timeout?: number) => Promise<DaytonaExecuteResponse>\n    /** Present in recent SDKs; only `execStream` uses it. */\n    createPty?: (options: {\n      /**\n       * REQUIRED by the API despite reading like a convenience handle: the\n       * SDK forwards it as the session id and the control plane rejects the\n       * create with 400 `session ID is required` when it is absent.\n       */\n      id: string\n      cwd?: string\n      envs?: Record<string, string>\n      cols?: number\n      rows?: number\n      onData?: (data: Uint8Array) => void\n    }) => Promise<DaytonaPtyHandle>\n    /** Terminals only: re-attach to a PTY session that outlived the host. */\n    connectPty?: (sessionId: string, options: { onData: (data: Uint8Array) => void }) => Promise<DaytonaPtyHandle>\n    killPtySession?: (sessionId: string) => Promise<void>\n  }\n  fs: {\n    /**\n     * A Node Buffer, not a bare Uint8Array — that is what the SDK declares and\n     * what its download path actually materializes (`Buffer.concat` over the\n     * response parts), so `readFile` decodes with `.toString('utf8')` instead\n     * of guarding a union. Leaning on that is only safe because the\n     * `@daytona/sdk` peer range pins `^0.187.0`: this interface is a\n     * hand-rolled structural type over a lazily-imported SDK, so a wider\n     * install returning a plain Uint8Array would decode to \"104,101,…\"\n     * at runtime with nothing failing at compile time.\n     */\n    downloadFile: (path: string) => Promise<Buffer>\n    uploadFile: (content: Uint8Array | Buffer, path: string) => Promise<unknown>\n    listFiles: (path: string) => Promise<DaytonaFileEntry[]>\n  }\n  getWorkDir?: () => Promise<string>\n  start?: (timeout?: number) => Promise<unknown>\n  delete: (timeout?: number) => Promise<unknown>\n  stop?: (timeout?: number) => Promise<unknown>\n  archive?: () => Promise<unknown>\n}\n\nexport interface DaytonaClientConfig {\n  apiKey?: string\n  apiUrl?: string\n  target?: string\n}\n\nexport interface DaytonaResources {\n  cpu?: number\n  memory?: number\n  disk?: number\n  gpu?: number\n  [key: string]: unknown\n}\n\nexport interface DaytonaCreateParams {\n  language?: string\n  snapshot?: string\n  image?: unknown\n  resources?: DaytonaResources\n  envVars?: Record<string, string>\n  [key: string]: unknown\n}\n\nexport interface DaytonaClient {\n  create: (params?: DaytonaCreateParams) => Promise<DaytonaSandbox>\n  get: (sandboxIdOrName: string) => Promise<DaytonaSandbox>\n}\n\nexport type DaytonaConstructor = new (config?: DaytonaClientConfig) => DaytonaClient\n\nexport function resolveDaytonaEnv(\n  optionEnv: Record<string, string> | undefined,\n  perSpawnEnv: Record<string, string> | undefined,\n): Record<string, string> | undefined {\n  const merged = { ...optionEnv, ...perSpawnEnv }\n  return Object.keys(merged).length > 0 ? merged : undefined\n}\n\nexport function normalizeDaytonaExecResult(response: DaytonaExecuteResponse): ExecResult {\n  return {\n    stdout: response.stdout ?? response.artifacts?.stdout ?? response.result ?? response.output ?? '',\n    stderr: response.stderr ?? '',\n    exitCode: typeof response.exitCode === 'number' ? response.exitCode : 0,\n  }\n}\n","/**\n * Live bidirectional `execStream` and PTY terminals of the Daytona sandbox\n * provider. Internal module.\n */\n\nimport type { Logger } from '../logger'\nimport type { DaytonaPtyHandle, DaytonaSandbox } from './daytona-sdk'\nimport type { SandboxProvider } from './sandbox'\nimport type { StreamHandle, TerminalProcess } from './types'\nimport { Buffer } from 'node:buffer'\nimport { normalizeDaytonaExecResult, resolveDaytonaEnv } from './daytona-sdk'\nimport { TERMINAL_ENV } from './local-terminal'\nimport { StreamQueue } from './stream-queue'\n\n/** Registry lookup of the provider (`get` in `createDaytonaProvider`). */\nexport type DaytonaLiveGet = (sandboxId: string) => { sandbox: DaytonaSandbox, env?: Record<string, string>, owned: boolean }\n\n/** A `TerminalProcess` over a Daytona PTY session. Input is chained to keep keystroke order. */\nfunction daytonaTerminal(sandbox: DaytonaSandbox, id: string, pty: DaytonaPtyHandle): TerminalProcess {\n  let input: Promise<unknown> = Promise.resolve()\n  let killed: Promise<void> | null = null\n  return {\n    id,\n    reconnectable: sandbox.process.connectPty !== undefined,\n    write: (data) => {\n      input = input.then(() => pty.sendInput(data)).catch(() => {})\n    },\n    resize: (cols, rows) => {\n      void pty.resize?.(cols, rows).catch(() => {})\n    },\n    kill: () => (killed ??= (async () => {\n      await (sandbox.process.killPtySession?.(id) ?? pty.kill?.())?.catch(() => {})\n      await pty.disconnect().catch(() => {})\n    })()),\n    detach: () => pty.disconnect().then(() => {}, () => {}),\n    exited: pty.wait().then(result => result?.exitCode ?? -1, () => -1),\n  }\n}\n\nexport function daytonaTerminalMethods(get: DaytonaLiveGet): Required<Pick<SandboxProvider, 'openTerminal' | 'reconnectTerminal'>> {\n  return {\n    /**\n     * A login shell in the sandbox through a Daytona PTY session. Sessions\n     * persist server-side after the websocket drops, which is what lets\n     * `reconnectTerminal` find them again by id, and why `kill` must end the\n     * session rather than just disconnect.\n     */\n    async openTerminal(sandboxId, options): Promise<TerminalProcess> {\n      const { sandbox, env } = get(sandboxId)\n      if (!sandbox.process.createPty)\n        throw new Error('Daytona SDK is too old: `process.createPty` is required for terminals.')\n      const id = `zidane-tty-${Math.random().toString(36).slice(2, 10)}`\n      const pty = await sandbox.process.createPty({\n        id,\n        ...(options.cwd ? { cwd: options.cwd } : {}),\n        envs: resolveDaytonaEnv(env, { ...options.env, ...TERMINAL_ENV }) ?? {},\n        cols: options.cols,\n        rows: options.rows,\n        onData: options.onData,\n      })\n      await pty.waitForConnection()\n      return daytonaTerminal(sandbox, id, pty)\n    },\n\n    async reconnectTerminal(sandboxId, id, options): Promise<TerminalProcess | null> {\n      const { sandbox } = get(sandboxId)\n      if (!sandbox.process.connectPty)\n        return null\n      const pty = await sandbox.process.connectPty(id, { onData: options.onData }).catch(() => null)\n      if (!pty)\n        return null\n      await pty.waitForConnection()\n      const terminal = daytonaTerminal(sandbox, id, pty)\n      terminal.resize(options.cols, options.rows)\n      return terminal\n    },\n  }\n}\n\nexport function daytonaStreamMethods(get: DaytonaLiveGet, logger: Logger): Required<Pick<SandboxProvider, 'execStream'>> {\n  return {\n    /**\n     * Live bidirectional stream — see `ExecutionContext.execStream`.\n     *\n     * PTY-backed, and not by preference: Daytona's process + session API\n     * exposes no stdin at all (sessions are fire-and-forget with log\n     * streaming), so a pseudo-terminal is the only interactive channel the\n     * platform offers. That forces three mitigations, all in the launch\n     * wrapper below, because a PTY is a terminal and a protocol stream is\n     * not:\n     *\n     *  1. `stty -echo` — a terminal echoes everything written to stdin back\n     *     onto stdout. Without this the caller reads its own requests back\n     *     as if they were responses.\n     *  2. `stty raw` — canonical mode rewrites `\\n`→`\\r\\n` and caps a line\n     *     at ~4096 bytes. Protocol frames routinely exceed that and would\n     *     be silently truncated mid-message.\n     *  3. `2><file>` — a PTY has ONE stream, so the child's stderr would\n     *     otherwise interleave into the protocol data and corrupt framing.\n     *     It is redirected to a file inside the sandbox and surfaced on the\n     *     returned handle by polling that file through the exec API.\n     *\n     * The mitigations must run before the child's first byte — but the\n     * launch line ITSELF is typed into a canonical-mode terminal, so it is\n     * echoed once (a short non-JSON line the transport's tolerant framing\n     * discards) and subject to the ~4096-byte line cap. That is why the\n     * real command lives in an uploaded script and the typed line stays\n     * short and constant: a long command line would be truncated before\n     * `stty` ever ran. The script also restores `sh` compound-command\n     * semantics that a bare `exec <command>` would break.\n     */\n    async execStream(sandboxId, command, opts): Promise<StreamHandle> {\n      const { sandbox, env } = get(sandboxId)\n\n      if (!sandbox.process.createPty) {\n        throw new Error(\n          'Daytona SDK is too old: `process.createPty` is required for execStream '\n          + '(used to run stdio MCP servers inside the sandbox).',\n        )\n      }\n\n      opts?.signal?.throwIfAborted()\n\n      const token = Math.random().toString(36).slice(2, 10)\n      const stderrPath = `/tmp/.zidane-stream-${token}.err`\n      const scriptPath = `/tmp/.zidane-stream-${token}.sh`\n\n      // `exec 2>` rebinds the shell's stderr before the command runs, so\n      // the command text needs no rewriting and stays compound-safe.\n      await sandbox.fs.uploadFile(\n        Buffer.from(`exec 2>${stderrPath}\\n${command}\\n`),\n        scriptPath,\n      )\n\n      // See the E2B counterpart: the PTY's `onData` is a sync `void`\n      // callback, so a stalled consumer can only be reported, never slowed.\n      const warnBacklog = (which: string) => (bytes: number) =>\n        logger.warn('execStream consumer is not draining output', { sandboxId, stream: which, bufferedBytes: bytes })\n      const stdout = new StreamQueue(warnBacklog('stdout'))\n      const stderr = new StreamQueue(warnBacklog('stderr'))\n\n      // Everything the shell emits before the child is actually running is\n      // NOISE that must never reach the caller: the echo of our own launch\n      // line (typed before `-echo` takes effect), the login shell's prompt,\n      // and its line-editor redraw escapes. `createPty` is `lazyStart`, so\n      // the shell frequently does not exist yet when we type — it boots\n      // afterwards and REPLAYS the buffered input through its line editor.\n      // Observed on a stock sandbox: the stream opened with the echoed\n      // launch line, the echoed first request, `\\u001b[?2004h` bracketed\n      // paste, and a `%` prompt. An MCP client parses that echoed request\n      // as a message and the handshake collapses.\n      //\n      // So: gate the stream on a sentinel the CHILD side prints, and drop\n      // every byte before it. The sentinel is assembled by `printf` at\n      // runtime (`Z-%s-READY` + token) so the echoed *source* line, which\n      // contains the format string rather than the result, cannot match it.\n      const sentinel = `Z-${token}-READY`\n      let gateOpen = false\n      let gateBuffer = ''\n      let openGate: () => void = () => {}\n      const gateReady = new Promise<void>((r) => { openGate = r })\n\n      const pty = await sandbox.process.createPty({\n        id: `zidane-stream-${token}`,\n        ...(opts?.cwd ? { cwd: opts.cwd } : {}),\n        envs: resolveDaytonaEnv(env, opts?.env) ?? {},\n        onData: (data: Uint8Array) => {\n          if (gateOpen) {\n            stdout.push(data)\n            return\n          }\n          gateBuffer += Buffer.from(data).toString('utf8')\n          const at = gateBuffer.indexOf(sentinel)\n          if (at === -1) {\n            // Bounded: never let pre-gate noise grow without limit, but keep\n            // a tail longer than the sentinel so it can't be split away.\n            if (gateBuffer.length > 64 * 1024)\n              gateBuffer = gateBuffer.slice(-1024)\n            return\n          }\n          gateOpen = true\n          openGate()\n          // Everything after the sentinel's trailing newline is real output.\n          const rest = gateBuffer.slice(at + sentinel.length).replace(/^\\r?\\n/, '')\n          gateBuffer = ''\n          if (rest.length > 0)\n            stdout.push(new TextEncoder().encode(rest))\n        },\n      })\n      await pty.waitForConnection()\n\n      // Short, constant, and under any canonical line cap. `exec` replaces\n      // the login shell so the PTY's lifetime is the script's lifetime and\n      // no shell prompt can reach stdout.\n      await pty.sendInput(`stty raw -echo; printf 'Z-%s-READY\\\\n' ${token}; exec sh ${scriptPath}\\n`)\n\n      // Block until the child is genuinely live. Without this the caller can\n      // write its first frame into a shell that hasn't started, where it is\n      // echoed back and misread as a response.\n      let gateTimer: ReturnType<typeof setTimeout> | undefined\n      await Promise.race([\n        gateReady,\n        new Promise<void>((r) => { gateTimer = setTimeout(r, 30_000) }),\n      ])\n      clearTimeout(gateTimer)\n      if (!gateOpen) {\n        // Full teardown, not just a disconnect: Daytona PTY sessions persist\n        // server-side after the websocket drops, so a bare disconnect leaks\n        // one login shell plus two /tmp files per attempt — a bootstrap\n        // retry loop against a broken image would stack them until the\n        // sandbox dies.\n        await (pty.kill?.() ?? Promise.resolve()).catch(() => {})\n        await pty.disconnect().catch(() => {})\n        await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {})\n        throw new Error(\n          `Daytona execStream: PTY did not reach the ready sentinel within 30s `\n          + `(sandbox ${sandboxId}). The login shell may not have started.`,\n        )\n      }\n\n      // stderr file → handle.stderr. Poll rather than stream: the exec API\n      // is the only other channel into the sandbox, and diagnostics don't\n      // need latency. Byte offsets keep re-reads incremental.\n      //\n      // The offset comes from the FILE (`wc -c`), never from measuring the\n      // returned content: an exec API that trims a trailing newline from\n      // command output would make a content-derived offset under-advance by\n      // one byte per poll, re-emitting the tail byte forever. The size rides\n      // back on the same round trip as a `ZEOF-<token>:` suffix; content is\n      // whatever precedes it, so content-side transforms can't drift the\n      // cursor either.\n      let stderrOffset = 0\n      let torndown = false\n      const eofMark = `ZEOF-${token}:`\n      const drainStderr = async (): Promise<void> => {\n        try {\n          const res = normalizeDaytonaExecResult(await sandbox.process.executeCommand(\n            `tail -c +${stderrOffset + 1} ${stderrPath} 2>/dev/null; printf '${eofMark}%s' \"$(wc -c < ${stderrPath} 2>/dev/null || echo 0)\"`,\n          ))\n          const at = res.stdout.lastIndexOf(eofMark)\n          if (at === -1)\n            return\n          const content = res.stdout.slice(0, at)\n          const size = Number.parseInt(res.stdout.slice(at + eofMark.length).trim(), 10)\n          if (content.length > 0)\n            stderr.push(new TextEncoder().encode(content))\n          if (Number.isFinite(size) && size > stderrOffset)\n            stderrOffset = size\n        }\n        catch {\n          // Diagnostic channel — polling failures must never surface as\n          // protocol errors.\n        }\n      }\n      const stderrTimer = setInterval(() => { void drainStderr() }, 2000)\n      // Guarded: Bun/Node timers support unref, test fakes may not.\n      ;(stderrTimer as { unref?: () => void }).unref?.()\n\n      // Shared teardown for both exit paths (natural exit and kill): one\n      // final stderr drain so a crash message isn't lost, then remove the\n      // script + stderr files that would otherwise accumulate in /tmp for\n      // the sandbox's lifetime.\n      const teardown = async (): Promise<void> => {\n        if (torndown)\n          return\n        torndown = true\n        clearInterval(stderrTimer)\n        await drainStderr()\n        await sandbox.process.executeCommand(`rm -f ${scriptPath} ${stderrPath}`).catch(() => {})\n        stdout.close()\n        stderr.close()\n      }\n\n      const exited = pty.wait()\n        .then(result => result?.exitCode ?? 0)\n        .catch(() => 137)\n        .finally(teardown)\n\n      const kill = async (): Promise<void> => {\n        // A PTY login shell never exits on its own — killing it IS the\n        // normal termination path here, not an error path.\n        await (pty.kill?.() ?? Promise.resolve()).catch(() => {})\n        await pty.disconnect().catch(() => {})\n        await teardown()\n      }\n\n      if (opts?.signal) {\n        if (opts.signal.aborted) {\n          void kill()\n        }\n        else {\n          // Detach on exit — the (typically run-long) signal otherwise\n          // retains the `kill` closure and the PTY handle for the rest of\n          // the run, one dead closure per exec.\n          const onAbort = () => { void kill() }\n          const detach = () => opts.signal!.removeEventListener('abort', onAbort)\n          opts.signal.addEventListener('abort', onAbort, { once: true })\n          exited.then(detach, detach)\n        }\n      }\n\n      return {\n        pid: pty.pid ?? -1,\n        stdout,\n        stderr,\n        write: async (data: Uint8Array): Promise<void> => {\n          await pty.sendInput(data)\n        },\n        kill,\n        exited,\n      }\n    },\n  }\n}\n","/**\n * Daytona sandbox provider.\n *\n * Implements {@link SandboxProvider} on top of Daytona sandboxes. Pair it with\n * {@link createSandboxContext} to run an agent's shell + filesystem tools\n * inside a Daytona sandbox:\n *\n * ```ts\n * import { createSandboxContext } from 'zidane/contexts'\n * import { createDaytonaProvider } from 'zidane/contexts/daytona'\n *\n * const execution = createSandboxContext(createDaytonaProvider())\n * ```\n *\n * Requires `@daytona/sdk` as an optional peer dependency:\n * `bun add @daytona/sdk`.\n */\nimport type { Logger } from '../logger'\nimport type { DaytonaClientConfig, DaytonaConstructor, DaytonaCreateParams, DaytonaResources, DaytonaSandbox } from './daytona-sdk'\nimport type { SandboxProvider } from './sandbox'\nimport type { ExecResult, SpawnConfig } from './types'\nimport { Buffer } from 'node:buffer'\nimport { errorMessage } from '../errors'\nimport { consoleSink, createLogger } from '../logger'\nimport { normalizeDaytonaExecResult, resolveDaytonaEnv } from './daytona-sdk'\nimport { daytonaStreamMethods, daytonaTerminalMethods } from './daytona-stream'\nimport { capBufferedExecOutput } from './output-cap'\n\nexport { normalizeDaytonaExecResult, resolveDaytonaEnv } from './daytona-sdk'\n\n// ---------------------------------------------------------------------------\n// Provider options\n// ---------------------------------------------------------------------------\n\nexport type DaytonaOnDestroy = 'delete' | 'kill' | 'stop' | 'pause' | 'archive' | 'leave'\n\nexport interface DaytonaProviderOptions {\n  /** Daytona API key. Falls back to the `DAYTONA_API_KEY` env var when omitted. */\n  apiKey?: string\n  /** Daytona API URL. Falls back to `DAYTONA_API_URL`, then Daytona's hosted default. */\n  apiUrl?: string\n  /** Daytona target / region. Falls back to `DAYTONA_TARGET`, then the org default. */\n  target?: string\n  /**\n   * Attach to a pre-existing sandbox by id or name instead of creating a fresh\n   * one. By default the provider treats attached sandboxes as externally owned\n   * and leaves them running on destroy/failure (set {@link ownAttached} to take\n   * over the lifecycle).\n   */\n  sandboxId?: string\n  /**\n   * Take ownership of an attached ({@link sandboxId}) sandbox's lifecycle, so\n   * `destroy()` applies {@link onDestroy} to it (stop / archive / delete)\n   * instead of leaving it running.\n   *\n   * The intended caller is a durable host that *owns* the sandbox across\n   * invocations: mint it once, journal its id, re-attach via `sandboxId` on\n   * every replay/resume, and clean it up at the end of the logical run. Without\n   * this an attached sandbox can never be stopped/deleted through the provider —\n   * a leak for host-owned sandboxes. No effect when creating a fresh sandbox\n   * (those are always owned). Spawn-time failures (readiness timeout, pregame\n   * error) still never delete a pre-existing attached sandbox — only sandboxes\n   * this provider *created* are auto-cleaned on spawn failure.\n   *\n   * Default: `false`.\n   */\n  ownAttached?: boolean\n  /** Daytona snapshot used when creating a fresh sandbox. */\n  snapshot?: string\n  /** Runtime used for Daytona's code tooling. Shell execution works either way. */\n  language?: string\n  /** Daytona image/declarative builder input used when creating a fresh sandbox. */\n  image?: unknown\n  /** Daytona sandbox resources. */\n  resources?: DaytonaResources\n  /** Default working directory, applied when a spawn doesn't set `SpawnConfig.cwd`. */\n  cwd?: string\n  /** Environment variables baked into the sandbox and re-sent on every command. */\n  env?: Record<string, string>\n  /** Logger for provider-level lifecycle lines. */\n  logger?: Logger\n  /** Total deadline, in seconds, for the post-create readiness probe. Defaults to `60`. */\n  readinessTimeoutSeconds?: number\n  /** Setup script to upload and run once the sandbox is ready. */\n  pregame?: { name: string, content: string }\n  /**\n   * What to do with an owned sandbox on destroy:\n   *\n   * - `'delete'` / `'kill'` (default) — call `sandbox.delete()`.\n   * - `'stop'` / `'pause'` — call `sandbox.stop()` so Daytona preserves state\n   *   according to the runner's stop semantics.\n   * - `'archive'` — stop, then archive for longer-term persistence.\n   * - `'leave'` — make no API call.\n   */\n  onDestroy?: DaytonaOnDestroy\n}\n\n/** Per-probe timeout for the readiness `true` command. */\nconst READINESS_PROBE_TIMEOUT_SECONDS = 5\n/** Pause between readiness probes while the sandbox is still warming up. */\nconst READINESS_BACKOFF_MS = 250\n/** Setup scripts commonly install dependencies, so give them a generous cap. */\nconst PREGAME_TIMEOUT_SECONDS = 30 * 60\n\nexport interface DaytonaReadinessOptions {\n  /** Total deadline in seconds. `<= 0` disables the probe entirely. */\n  timeoutSeconds: number\n  /** Optional cleanup for owned sandboxes that never become ready. */\n  cleanupOnTimeout?: () => Promise<void>\n  /** Clock source — injectable for deterministic tests. */\n  now?: () => number\n  /** Sleep between probes — injectable for deterministic tests. */\n  sleep?: (ms: number) => Promise<void>\n}\n\nfunction capExecResult(result: ExecResult): ExecResult {\n  return { ...capBufferedExecOutput(result.stdout, result.stderr), exitCode: result.exitCode }\n}\n\nfunction normalizeDaytonaExecError(error: unknown): ExecResult {\n  const err = error as { exitCode?: unknown, stdout?: unknown, stderr?: unknown, result?: unknown, output?: unknown, message?: unknown }\n  if (typeof err.exitCode === 'number') {\n    return {\n      stdout: typeof err.stdout === 'string'\n        ? err.stdout\n        : typeof err.result === 'string'\n          ? err.result\n          : typeof err.output === 'string'\n            ? err.output\n            : '',\n      stderr: typeof err.stderr === 'string' ? err.stderr : typeof err.message === 'string' ? err.message : '',\n      exitCode: err.exitCode,\n    }\n  }\n  return { stdout: '', stderr: error instanceof Error ? error.message : String(error), exitCode: 124 }\n}\n\nfunction toClientConfig(apiKey?: string, apiUrl?: string, target?: string): DaytonaClientConfig | undefined {\n  const config: DaytonaClientConfig = {}\n  if (apiKey !== undefined)\n    config.apiKey = apiKey\n  if (apiUrl !== undefined)\n    config.apiUrl = apiUrl\n  if (target !== undefined)\n    config.target = target\n  return Object.keys(config).length > 0 ? config : undefined\n}\n\nfunction takeString(value: unknown): string | undefined {\n  return typeof value === 'string' && value.length > 0 ? value : undefined\n}\n\nexport function resolveDaytonaCreateParams(\n  sandboxConfig: Record<string, unknown>,\n  options: DaytonaProviderOptions,\n  envVars: Record<string, string> | undefined,\n): DaytonaCreateParams | undefined {\n  const reserved = new Set(['provider', 'apiKey', 'apiUrl', 'target', 'sandboxId'])\n  const params: DaytonaCreateParams = {}\n\n  for (const [key, value] of Object.entries(sandboxConfig)) {\n    if (!reserved.has(key) && value !== undefined)\n      params[key] = value\n  }\n\n  const language = takeString(sandboxConfig.language) ?? options.language\n  const snapshot = takeString(sandboxConfig.snapshot) ?? options.snapshot\n  const image = sandboxConfig.image ?? options.image\n  const resources = (sandboxConfig.resources as DaytonaResources | undefined) ?? options.resources\n  const configEnvVars = sandboxConfig.envVars as Record<string, string> | undefined\n  const mergedEnvVars = resolveDaytonaEnv(envVars, configEnvVars)\n\n  if (language !== undefined)\n    params.language = language\n  if (snapshot !== undefined)\n    params.snapshot = snapshot\n  if (image !== undefined)\n    params.image = image\n  if (resources !== undefined)\n    params.resources = resources\n  if (mergedEnvVars !== undefined)\n    params.envVars = mergedEnvVars\n\n  return Object.keys(params).length > 0 ? params : undefined\n}\n\nexport async function waitForDaytonaReady(\n  sandbox: DaytonaSandbox,\n  logger: Logger,\n  opts: DaytonaReadinessOptions,\n): Promise<void> {\n  if (opts.timeoutSeconds <= 0)\n    return\n\n  const now = opts.now ?? Date.now\n  const sleep = opts.sleep ?? (ms => new Promise<void>(resolve => setTimeout(resolve, ms)))\n  const start = now()\n  const deadline = start + opts.timeoutSeconds * 1000\n\n  logger.info('waiting for Daytona sandbox to initialize', { sandboxId: sandbox.id })\n\n  while (true) {\n    try {\n      await sandbox.process.executeCommand('true', undefined, undefined, READINESS_PROBE_TIMEOUT_SECONDS)\n      logger.info('Daytona sandbox ready', { sandboxId: sandbox.id, elapsedMs: now() - start })\n      return\n    }\n    catch {\n      if (now() >= deadline) {\n        await opts.cleanupOnTimeout?.().catch(() => {})\n        throw new Error(`Daytona sandbox ${sandbox.id} did not become ready within ${opts.timeoutSeconds}s`)\n      }\n      await sleep(READINESS_BACKOFF_MS)\n    }\n  }\n}\n\nexport async function runDaytonaPregame(\n  sandbox: DaytonaSandbox,\n  logger: Logger,\n  opts: { name: string, content: string, cwd?: string, envVars?: Record<string, string> },\n): Promise<void> {\n  const path = `/tmp/${opts.name}`\n  logger.info('running Daytona pregame script', { sandboxId: sandbox.id, path })\n  await sandbox.fs.uploadFile(Buffer.from(opts.content), path)\n\n  const quoted = JSON.stringify(path)\n  let result: ExecResult\n  try {\n    result = normalizeDaytonaExecResult(\n      await sandbox.process.executeCommand(`chmod +x ${quoted} && ${quoted}`, opts.cwd, opts.envVars, PREGAME_TIMEOUT_SECONDS),\n    )\n  }\n  catch (err) {\n    result = normalizeDaytonaExecError(err)\n  }\n\n  if (result.exitCode !== 0) {\n    logger.error('Daytona pregame script failed', { sandboxId: sandbox.id, exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr })\n    throw new Error(`Daytona pregame script ${opts.name} failed with exit code ${result.exitCode}`)\n  }\n\n  logger.info('Daytona pregame ready', { sandboxId: sandbox.id, stdout: result.stdout, stderr: result.stderr })\n}\n\n// ---------------------------------------------------------------------------\n// Provider\n// ---------------------------------------------------------------------------\n\nexport function createDaytonaProvider(options: DaytonaProviderOptions = {}): SandboxProvider {\n  const live = new Map<string, { sandbox: DaytonaSandbox, env?: Record<string, string>, owned: boolean }>()\n  const logger = options.logger ?? createLogger(consoleSink())\n  const readinessTimeoutSeconds = options.readinessTimeoutSeconds ?? 60\n\n  async function loadSdk(): Promise<DaytonaConstructor> {\n    try {\n      const mod = await import('@daytona/sdk') as { Daytona: DaytonaConstructor }\n      return mod.Daytona\n    }\n    catch (err) {\n      // Distinguish \"not installed\" from \"installed but failed to load\". This\n      // used to be a bare `catch` that reported the install hint either way,\n      // which sent people to `bun add` a package that was already present. The\n      // realistic load failure is a `tslib` hoist: `@daytona/sdk` declares no\n      // tslib dependency of its own and reaches AWS SDK v3 through\n      // `@aws-sdk/client-s3`, so a stale `@aws-crypto` v3/v4 floor\n      // (`tslib: ^1.11.1`) can win the hoist and the SDK's initializer helpers\n      // resolve against tslib 1.x, which lacks them. Fix with a root\n      // `overrides: { \"tslib\": \"^2.8.1\" }` — see `docs/RESTATE.md`.\n      const message = errorMessage(err)\n      const notInstalled = /cannot find (?:module|package)|module not found|failed to resolve/i.test(message)\n      throw new Error(\n        notInstalled\n          ? '@daytona/sdk is required for the Daytona sandbox provider. Install it with: bun add @daytona/sdk'\n          : `@daytona/sdk is installed but failed to load: ${message}. If this mentions tslib, pin it with a root override: \"overrides\": { \"tslib\": \"^2.8.1\" }. See docs/RESTATE.md.`,\n        { cause: err },\n      )\n    }\n  }\n\n  function get(sandboxId: string): { sandbox: DaytonaSandbox, env?: Record<string, string>, owned: boolean } {\n    const entry = live.get(sandboxId)\n    if (!entry)\n      throw new Error(`Daytona sandbox ${sandboxId} is not tracked by this provider`)\n    return entry\n  }\n\n  async function deleteOwnedSandbox(sandbox: DaytonaSandbox): Promise<void> {\n    try {\n      await sandbox.delete()\n    }\n    catch {\n      // Already gone — nothing to clean up.\n    }\n  }\n\n  async function stopOwnedSandbox(sandbox: DaytonaSandbox): Promise<void> {\n    if (!sandbox.stop) {\n      logger.error('cannot stop Daytona sandbox: this @daytona/sdk install exposes no stop() method; leaving it running', { sandboxId: sandbox.id })\n      return\n    }\n    try {\n      await sandbox.stop()\n      logger.info('stopped Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)', { sandboxId: sandbox.id })\n    }\n    catch (err) {\n      logger.error('failed to stop Daytona sandbox; it will run until Daytona lifecycle policy stops it', { sandboxId: sandbox.id, error: err instanceof Error ? err.message : String(err) })\n    }\n  }\n\n  async function archiveOwnedSandbox(sandbox: DaytonaSandbox): Promise<void> {\n    if (!sandbox.stop || !sandbox.archive) {\n      logger.error('cannot archive Daytona sandbox: this @daytona/sdk install exposes no stop() and archive() pair; leaving it running', { sandboxId: sandbox.id })\n      return\n    }\n    try {\n      await sandbox.stop()\n      await sandbox.archive()\n      logger.info('archived Daytona sandbox; reconnect later via the sandboxId option (CLI: --sandbox)', { sandboxId: sandbox.id })\n    }\n    catch (err) {\n      logger.error('failed to archive Daytona sandbox; it will run until Daytona lifecycle policy stops it', { sandboxId: sandbox.id, error: err instanceof Error ? err.message : String(err) })\n    }\n  }\n\n  async function startAttachedSandboxIfNeeded(sandbox: DaytonaSandbox): Promise<void> {\n    if (sandbox.state !== 'stopped' && sandbox.state !== 'archived')\n      return\n    if (!sandbox.start) {\n      logger.error('cannot start Daytona sandbox before attach readiness probe: this @daytona/sdk install exposes no start() method', { sandboxId: sandbox.id, state: sandbox.state })\n      return\n    }\n    logger.info('starting Daytona sandbox before attach readiness probe', { sandboxId: sandbox.id, state: sandbox.state })\n    await sandbox.start(readinessTimeoutSeconds > 0 ? readinessTimeoutSeconds : undefined)\n  }\n\n  const streamM = daytonaStreamMethods(get, logger)\n  const termM = daytonaTerminalMethods(get)\n\n  return {\n    name: 'daytona',\n\n    async spawn(config: SpawnConfig = {}): Promise<{ id: string, cwd: string }> {\n      const Daytona = await loadSdk()\n      const sb: Record<string, unknown> = config.sandbox ?? {}\n\n      const apiKey = takeString(sb.apiKey) ?? options.apiKey\n      const apiUrl = takeString(sb.apiUrl) ?? options.apiUrl\n      const target = takeString(sb.target) ?? options.target\n      const connectId = takeString(sb.sandboxId) ?? options.sandboxId\n      const snapshot = takeString(sb.snapshot) ?? options.snapshot\n      const envVars = resolveDaytonaEnv(options.env, config.env)\n\n      const daytona = new Daytona(toClientConfig(apiKey, apiUrl, target))\n      let attached = connectId !== undefined\n      let sandbox = connectId !== undefined\n        ? await daytona.get(connectId)\n        : await daytona.create(resolveDaytonaCreateParams(sb, options, envVars))\n\n      // An attached sandbox built from a stale snapshot is recreated from\n      // scratch: the caller's snapshot pin wins over the journaled sandbox.\n      if (attached && snapshot !== undefined && sandbox.snapshot !== snapshot) {\n        logger.info('recreating Daytona sandbox: snapshot changed', {\n          sandboxId: sandbox.id,\n          previousSnapshot: sandbox.snapshot,\n          newSnapshot: snapshot,\n        })\n        await deleteOwnedSandbox(sandbox)\n        attached = false\n        sandbox = await daytona.create(resolveDaytonaCreateParams(sb, options, envVars))\n      }\n\n      // Lifecycle ownership drives `destroy()` (onDestroy). A created sandbox is\n      // always owned; an attached one is owned only when the host opts in via\n      // `ownAttached`. Spawn-FAILURE cleanup is separate (see below) and keyed\n      // on `!attached` so a pre-existing sandbox is never auto-deleted.\n      const owned = !attached || options.ownAttached === true\n\n      if (attached)\n        await startAttachedSandboxIfNeeded(sandbox)\n\n      live.set(sandbox.id, { sandbox, env: envVars, owned })\n\n      try {\n        await waitForDaytonaReady(sandbox, logger, {\n          timeoutSeconds: readinessTimeoutSeconds,\n          // Only auto-delete a sandbox we CREATED on readiness failure — never a\n          // pre-existing attached one, even when we own its lifecycle.\n          ...(!attached ? { cleanupOnTimeout: () => deleteOwnedSandbox(sandbox) } : {}),\n        })\n      }\n      catch (err) {\n        live.delete(sandbox.id)\n        throw err\n      }\n\n      const requestedCwd = config.cwd ?? options.cwd\n      let cwd: string\n      if (requestedCwd) {\n        cwd = requestedCwd\n        await sandbox.process.executeCommand(`mkdir -p ${JSON.stringify(cwd)}`).catch(() => {})\n      }\n      else if (sandbox.getWorkDir) {\n        cwd = await sandbox.getWorkDir().catch(() => '')\n        if (!cwd)\n          cwd = await sandbox.process.executeCommand('pwd').then(r => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => '') || '/home/daytona'\n      }\n      else {\n        cwd = await sandbox.process.executeCommand('pwd').then(r => normalizeDaytonaExecResult(r).stdout.trim()).catch(() => '') || '/home/daytona'\n      }\n\n      if (options.pregame) {\n        try {\n          await runDaytonaPregame(sandbox, logger, { name: options.pregame.name, content: options.pregame.content, cwd, envVars })\n        }\n        catch (err) {\n          // Spawn-failure cleanup: only delete a sandbox we created, never a\n          // pre-existing attached one (the host owns its prior state).\n          if (!attached)\n            await deleteOwnedSandbox(sandbox)\n          live.delete(sandbox.id)\n          throw err\n        }\n      }\n\n      return { id: sandbox.id, cwd }\n    },\n\n    openTerminal: termM.openTerminal,\n\n    reconnectTerminal: termM.reconnectTerminal,\n\n    async exec(sandboxId, command, opts): Promise<ExecResult> {\n      const { sandbox, env } = get(sandboxId)\n      const timeoutSeconds = opts?.timeout ?? 30\n      try {\n        // The SDK buffers the streams uncapped (see the KNOWN RESIDUAL note\n        // on `ExecutionContext.fileSize`) — cap host-side before the strings\n        // propagate into tool results and session history.\n        return capExecResult(normalizeDaytonaExecResult(\n          await sandbox.process.executeCommand(\n            command,\n            opts?.cwd,\n            resolveDaytonaEnv(env, opts?.env),\n            timeoutSeconds > 0 ? timeoutSeconds : undefined,\n          ),\n        ))\n      }\n      catch (err) {\n        return capExecResult(normalizeDaytonaExecError(err))\n      }\n    },\n\n    execStream: streamM.execStream,\n\n    async readFile(sandboxId, path): Promise<string> {\n      const data = await get(sandboxId).sandbox.fs.downloadFile(path)\n      return data.toString('utf8')\n    },\n\n    async writeFile(sandboxId, path, content, encoding: BufferEncoding = 'utf-8'): Promise<void> {\n      const data = typeof content === 'string' ? Buffer.from(content, encoding) : content\n      await get(sandboxId).sandbox.fs.uploadFile(data, path)\n    },\n\n    async listFiles(sandboxId, path): Promise<string[]> {\n      const entries = await get(sandboxId).sandbox.fs.listFiles(path)\n      // Trailing `/` on directories — parity with process/docker contexts.\n      return entries.map(e => (e.isDir ? `${e.name}/` : e.name))\n    },\n\n    async destroy(sandboxId): Promise<void> {\n      const entry = live.get(sandboxId)\n      if (!entry)\n        return\n      if (entry.owned) {\n        const action = options.onDestroy ?? 'delete'\n        if (action === 'stop' || action === 'pause')\n          await stopOwnedSandbox(entry.sandbox)\n        else if (action === 'archive')\n          await archiveOwnedSandbox(entry.sandbox)\n        else if (action === 'delete' || action === 'kill')\n          await deleteOwnedSandbox(entry.sandbox)\n      }\n      live.delete(sandboxId)\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/defaults-Cx3zvDOV.js

@@ -0,0 +1,23 @@
+//#region src/media/defaults.ts
+/**
+* Built-in `mediaBudget` for chat, headless and Restate runs. Below Anthropic's
+* hard caps (100 images on 200k-window models, 600 otherwise; 32 MB request
+* body) with headroom for the text of a long conversation. Providers with a
+* lower cap (Bedrock: 20) lower `maxItems` via
+* `ProviderCapabilities.maxMediaPerRequest`.
+*/
+const DEFAULT_MEDIA_BUDGET = {
+	maxItems: 80,
+	maxBytes: 20971520
+};
+/**
+* Built-in `maxImageEdge`. The largest edge Anthropic accepts once a request
+* carries more than 20 images, so keeping media inline never trips that
+* rejection. Below the 2576 px high-resolution tier (Claude 4.7+), above the
+* 1568 px standard tier: most of the detail survives.
+*/
+const DEFAULT_MAX_IMAGE_EDGE = 2e3;
+//#endregion
+export { DEFAULT_MEDIA_BUDGET as n, DEFAULT_MAX_IMAGE_EDGE as t };
+
+//# sourceMappingURL=defaults-Cx3zvDOV.js.map

package/dist/defaults-Cx3zvDOV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults-Cx3zvDOV.js","names":[],"sources":["../src/media/defaults.ts"],"sourcesContent":["/**\n * Built-in `mediaBudget` for chat, headless and Restate runs. Below Anthropic's\n * hard caps (100 images on 200k-window models, 600 otherwise; 32 MB request\n * body) with headroom for the text of a long conversation. Providers with a\n * lower cap (Bedrock: 20) lower `maxItems` via\n * `ProviderCapabilities.maxMediaPerRequest`.\n */\nexport const DEFAULT_MEDIA_BUDGET = { maxItems: 80, maxBytes: 20 * 1024 * 1024 } as const\n\n/**\n * Built-in `maxImageEdge`. The largest edge Anthropic accepts once a request\n * carries more than 20 images, so keeping media inline never trips that\n * rejection. Below the 2576 px high-resolution tier (Claude 4.7+), above the\n * 1568 px standard tier: most of the detail survives.\n */\nexport const DEFAULT_MAX_IMAGE_EDGE = 2000\n"],"mappings":";;;;;;;;AAOA,MAAa,uBAAuB;CAAE,UAAU;CAAI,UAAU;AAAiB;;;;;;;AAQ/E,MAAa,yBAAyB"}