zidane 7.2.5 → 8.0.4

package/dist/contexts/e2b.js

@@ -1,382 +1 @@
-import { r as capBufferedExecOutput } from "../output-cap-C9zukcCj.js";
-import { t as alwaysQuote } from "../shell-quote-BmnhZmdM.js";
-import { r as createLogger, t as consoleSink } from "../logger--C1VQjwJ.js";
-import { t as StreamQueue } from "../stream-queue-Cd9OJxl7.js";
-import { Buffer } from "node:buffer";
-//#region src/contexts/e2b.ts
-/**
-* "Effectively unlimited" command timeout for `execStream`. 2^31-1 ms
-* (~24.8 days — far beyond any sandbox lifetime) because both edges are
-* cliffs: `0` is treated by `@connectrpc/connect`'s deadline signal as
-* already expired (instant DeadlineExceeded), and anything above 2^31-1
-* overflows `setTimeout` and fires immediately.
-*/
-const E2B_STREAM_TIMEOUT_MS = 2 ** 31 - 1;
-/** Per-probe timeout for the readiness `true` command. */
-const READINESS_PROBE_TIMEOUT_MS = 5e3;
-/** Pause between readiness probes while the sandbox is still warming up. */
-const READINESS_BACKOFF_MS = 250;
-/**
-* Command timeout for the pregame setup script. E2B's `commands.run` defaults
-* to 60s and offers no true "unlimited" — a `timeoutMs` of 0 is a 0ms deadline
-* (instant timeout), not "off". Setup scripts (`apt`/`pip` installs, builds)
-* routinely exceed 60s, so we pass a deliberately generous 30-minute ceiling.
-* The sandbox's own lifetime independently bounds anything longer.
-*/
-const PREGAME_TIMEOUT_MS = 1800 * 1e3;
-/**
-* Upload a setup ("pregame") script into a ready sandbox and execute it.
-*
-* Writes the script to `/tmp/<name>`, then `chmod +x`'s and runs it directly
-* (so a `#!/bin/bash` / `#!/usr/bin/env python3` shebang chooses the
-* interpreter) in `cwd` with `envs` applied — the same env the sandbox was
-* created with, so the script sees the run's `--env` / `--pass-env`. A
-* generous {@link PREGAME_TIMEOUT_MS} ceiling is used so long `apt`/`pip`
-* installs aren't killed by E2B's 60s command default. A non-zero exit
-* (whether E2B returns it or raises on it) throws, so the caller can tear the
-* sandbox down rather than prompt against a broken environment.
-*/
-async function runE2BPregame(sandbox, logger, opts) {
-	const path = `/tmp/${opts.name}`;
-	logger.info("running E2B pregame script", {
-		sandboxId: sandbox.sandboxId,
-		path
-	});
-	await sandbox.files.write(path, opts.content);
-	const quoted = JSON.stringify(path);
-	let result;
-	try {
-		result = await sandbox.commands.run(`chmod +x ${quoted} && ${quoted}`, {
-			cwd: opts.cwd,
-			envs: opts.envs,
-			timeoutMs: PREGAME_TIMEOUT_MS
-		});
-	} catch (err) {
-		const exitCode = typeof err?.exitCode === "number" ? err.exitCode : 124;
-		logger.error("E2B pregame script failed", {
-			sandboxId: sandbox.sandboxId,
-			exitCode,
-			stdout: err?.stdout ?? "",
-			stderr: err?.stderr ?? err?.message ?? ""
-		});
-		throw new Error(`E2B pregame script ${opts.name} failed with exit code ${exitCode}`);
-	}
-	if (result.exitCode !== 0) {
-		logger.error("E2B pregame script failed", {
-			sandboxId: sandbox.sandboxId,
-			exitCode: result.exitCode,
-			stdout: result.stdout,
-			stderr: result.stderr
-		});
-		throw new Error(`E2B pregame script ${opts.name} failed with exit code ${result.exitCode}`);
-	}
-	logger.info("E2B pregame ready", {
-		sandboxId: sandbox.sandboxId,
-		stdout: result.stdout,
-		stderr: result.stderr
-	});
-}
-/**
-* Block until an E2B sandbox is ready to run commands, or throw if it never
-* becomes ready within the deadline.
-*
-* The E2B control plane can hand back a sandbox id before the sandbox's `envd`
-* is accepting commands; the first real command then absorbs that cold start
-* and may time out. This polls a trivial `true` command on a short backoff,
-* logging a `waiting…` line up front and a `ready` line (with `elapsedMs`) on
-* success. On deadline exhaustion it best-effort kills the sandbox and throws.
-*
-* `now`/`sleep` are injectable purely for deterministic tests; in production
-* they default to `Date.now` and a real timer.
-*/
-async function waitForE2BReady(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 E2B sandbox to initialize", { sandboxId: sandbox.sandboxId });
-	while (true) try {
-		await sandbox.commands.run("true", { timeoutMs: READINESS_PROBE_TIMEOUT_MS });
-		logger.info("E2B sandbox ready", {
-			sandboxId: sandbox.sandboxId,
-			elapsedMs: now() - start
-		});
-		return;
-	} catch {
-		if (now() >= deadline) {
-			if (opts.killOnTimeout !== false) await sandbox.kill().catch(() => {});
-			throw new Error(`E2B sandbox ${sandbox.sandboxId} did not become ready within ${opts.timeoutSeconds}s`);
-		}
-		await sleep(READINESS_BACKOFF_MS);
-	}
-}
-/**
-* Resolve the effective E2B template, highest precedence first: the per-spawn
-* `SpawnConfig.sandbox.template`, then the factory `template` option, then the
-* `E2B_TEMPLATE` env var. Returns `undefined` (→ SDK's `base` default) when
-* none is set. The E2B SDK reads `E2B_API_KEY`/`E2B_DOMAIN` from the env but
-* NOT `E2B_TEMPLATE`, so this provider has to honor it itself.
-*/
-function resolveE2BTemplate(perSpawnTemplate, optionTemplate, env = process.env) {
-	return perSpawnTemplate || optionTemplate || env.E2B_TEMPLATE || void 0;
-}
-/**
-* Merge the factory-level {@link E2BProviderOptions.env} with the per-spawn
-* `SpawnConfig.env`, per-spawn winning on key conflicts. Returns `undefined`
-* when the merge is empty so callers can skip setting `envs` on the create
-* options entirely (rather than handing the SDK an empty object).
-*/
-function resolveE2BEnv(optionEnv, perSpawnEnv) {
-	const merged = {
-		...optionEnv,
-		...perSpawnEnv
-	};
-	return Object.keys(merged).length > 0 ? merged : void 0;
-}
-/**
-* Build a {@link SandboxProvider} backed by E2B.
-*
-* The provider owns a registry of live {@link E2BSandbox} instances keyed by
-* sandbox id, so the per-call `exec`/`readFile`/… hooks reuse the same warm
-* connection rather than reconnecting each time.
-*/
-function createE2BProvider(options = {}) {
-	const live = /* @__PURE__ */ new Map();
-	const logger = options.logger ?? createLogger(consoleSink());
-	const readinessTimeoutSeconds = options.readinessTimeoutSeconds ?? 60;
-	async function loadSdk() {
-		try {
-			return (await import("e2b")).Sandbox;
-		} catch {
-			throw new Error("e2b is required for the E2B sandbox provider. Install it with: bun add e2b");
-		}
-	}
-	function get(sandboxId) {
-		const entry = live.get(sandboxId);
-		if (!entry) throw new Error(`E2B sandbox ${sandboxId} is not tracked by this provider`);
-		return entry;
-	}
-	async function killOwnedSandbox(sandbox) {
-		try {
-			await sandbox.kill();
-		} catch {}
-	}
-	async function pauseOwnedSandbox(sandbox) {
-		try {
-			if (sandbox.pause) await sandbox.pause();
-			else if (sandbox.betaPause) await sandbox.betaPause();
-			else {
-				logger.error("cannot pause E2B sandbox: this e2b SDK exposes neither pause() nor betaPause() (expected e2b@^2); leaving it to time out", { sandboxId: sandbox.sandboxId });
-				return;
-			}
-			logger.info("paused E2B sandbox; reconnect later via the sandboxId option (CLI: --sandbox)", { sandboxId: sandbox.sandboxId });
-		} catch (err) {
-			logger.error("failed to pause E2B sandbox; it will run until its timeout", {
-				sandboxId: sandbox.sandboxId,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		}
-	}
-	return {
-		name: "e2b",
-		async spawn(config) {
-			const Sandbox = await loadSdk();
-			const sb = config.sandbox ?? {};
-			const apiKey = sb.apiKey ?? options.apiKey;
-			const domain = sb.domain ?? options.domain;
-			const template = resolveE2BTemplate(sb.template, options.template);
-			const timeoutSeconds = config.limits?.timeout ?? options.timeoutSeconds;
-			const connectId = sb.sandboxId ?? options.sandboxId;
-			const envs = resolveE2BEnv(options.env, config.env);
-			let sandbox;
-			const owned = connectId === void 0;
-			if (connectId !== void 0) {
-				const connectOpts = {};
-				if (apiKey !== void 0) connectOpts.apiKey = apiKey;
-				if (domain !== void 0) connectOpts.domain = domain;
-				if (timeoutSeconds !== void 0) connectOpts.timeoutMs = timeoutSeconds * 1e3;
-				sandbox = await Sandbox.connect(connectId, connectOpts);
-			} else {
-				const createOpts = {};
-				if (apiKey !== void 0) createOpts.apiKey = apiKey;
-				if (domain !== void 0) createOpts.domain = domain;
-				if (envs) createOpts.envs = envs;
-				if (timeoutSeconds !== void 0) createOpts.timeoutMs = timeoutSeconds * 1e3;
-				sandbox = template !== void 0 ? await Sandbox.create(template, createOpts) : await Sandbox.create(createOpts);
-			}
-			live.set(sandbox.sandboxId, {
-				sandbox,
-				env: envs,
-				owned
-			});
-			try {
-				await waitForE2BReady(sandbox, logger, {
-					timeoutSeconds: readinessTimeoutSeconds,
-					killOnTimeout: owned
-				});
-			} catch (err) {
-				live.delete(sandbox.sandboxId);
-				throw err;
-			}
-			const requestedCwd = config.cwd ?? options.cwd;
-			let cwd;
-			if (requestedCwd) {
-				cwd = requestedCwd;
-				await sandbox.commands.run(`mkdir -p ${JSON.stringify(cwd)}`).catch(() => {});
-			} else cwd = await sandbox.commands.run("pwd").then((r) => r.stdout.trim()).catch(() => "") || "/home/user";
-			if (options.pregame) try {
-				await runE2BPregame(sandbox, logger, {
-					name: options.pregame.name,
-					content: options.pregame.content,
-					cwd,
-					envs
-				});
-			} catch (err) {
-				if (owned) await sandbox.kill().catch(() => {});
-				live.delete(sandbox.sandboxId);
-				throw err;
-			}
-			return {
-				id: sandbox.sandboxId,
-				cwd
-			};
-		},
-		/**
-		* Live bidirectional stream — see `ExecutionContext.execStream`.
-		*
-		* Backed by E2B's pipe-based command API rather than `sandbox.pty`.
-		* Both can carry stdin, but a PTY would force us to defeat terminal
-		* semantics we never wanted (input echo, `\n`→`\r\n` rewriting, the
-		* ~4096-byte canonical line cap, and stdout/stderr merged into one
-		* stream). Pipes give split streams and byte-faithful framing for free.
-		*
-		* KNOWN RESIDUAL: `onStdout` / `onStderr` deliver `string`, already
-		* decoded by the SDK. A chunk boundary that splits a multibyte
-		* codepoint is therefore corrupted before it reaches us — we re-encode
-		* to bytes to satisfy the seam, but cannot recover what the decoder
-		* dropped. Newline framing and ASCII structure are unaffected, so
-		* JSON-RPC still parses; the damage would be confined to non-ASCII
-		* inside string values. If that ever bites, `sandbox.pty.create`
-		* hands back raw `Uint8Array` and the Daytona PTY path in
-		* `./daytona.ts` is the template for adopting it here.
-		*/
-		async execStream(sandboxId, command, opts) {
-			const { sandbox, env } = get(sandboxId);
-			opts?.signal?.throwIfAborted();
-			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 pidFile = `/tmp/.zidane-stream-${Math.random().toString(36).slice(2, 10)}.pid`;
-			const leader = `echo \$\$ > ${pidFile}; exec sh -c ${alwaysQuote(command)}`;
-			const wrapped = `if setsid -w true 2>/dev/null; then exec setsid -w sh -c ${alwaysQuote(leader)}; else exec sh -c ${alwaysQuote(leader)}; fi`;
-			const handle = await sandbox.commands.run(wrapped, {
-				background: true,
-				stdin: true,
-				timeoutMs: E2B_STREAM_TIMEOUT_MS,
-				...opts?.cwd ? { cwd: opts.cwd } : {},
-				envs: resolveE2BEnv(env, opts?.env),
-				onStdout: (data) => stdout.push(new TextEncoder().encode(data)),
-				onStderr: (data) => stderr.push(new TextEncoder().encode(data))
-			});
-			const pid = handle.pid;
-			const exited = handle.wait().then((result) => result?.exitCode ?? 0).catch((err) => typeof err?.exitCode === "number" ? err.exitCode : 137).finally(() => {
-				stdout.close();
-				stderr.close();
-			});
-			let commandExited = false;
-			exited.then(() => {
-				commandExited = true;
-			});
-			const readLeaderPid = async () => {
-				for (let attempt = 0; attempt < 20; attempt++) {
-					const probe = await sandbox.commands.run(`cat ${pidFile} 2>/dev/null || true`).catch(() => null);
-					const parsed = Number.parseInt(probe?.stdout?.trim() ?? "", 10);
-					if (Number.isFinite(parsed) && parsed > 0) return parsed;
-					if (commandExited) break;
-					await new Promise((r) => setTimeout(r, 50));
-				}
-				return -1;
-			};
-			const leaderPid = await readLeaderPid();
-			const kill = async () => {
-				if (leaderPid > 0) await sandbox.commands.run(`kill -TERM -${leaderPid} 2>/dev/null || kill -TERM ${leaderPid} 2>/dev/null || true`).catch(() => {});
-				await sandbox.commands.run(`rm -f ${pidFile}`).catch(() => {});
-				await sandbox.commands.kill?.(pid).catch(() => {});
-			};
-			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,
-				stdout,
-				stderr,
-				write: async (data) => {
-					if (!sandbox.commands.sendStdin) throw new Error("E2B SDK is too old: `commands.sendStdin` is required for execStream");
-					await sandbox.commands.sendStdin(pid, data);
-				},
-				kill,
-				exited
-			};
-		},
-		async exec(sandboxId, command, opts) {
-			const { sandbox, env } = get(sandboxId);
-			const timeoutMs = (opts?.timeout ?? 30) * 1e3;
-			try {
-				const result = await sandbox.commands.run(command, {
-					cwd: opts?.cwd,
-					envs: resolveE2BEnv(env, opts?.env),
-					timeoutMs: timeoutMs > 0 ? timeoutMs : void 0
-				});
-				return {
-					...capBufferedExecOutput(result.stdout, result.stderr),
-					exitCode: result.exitCode
-				};
-			} catch (err) {
-				if (typeof err?.exitCode === "number") return {
-					...capBufferedExecOutput(err.stdout ?? "", err.stderr ?? err.message ?? ""),
-					exitCode: err.exitCode
-				};
-				return {
-					stdout: "",
-					stderr: err?.message ?? String(err),
-					exitCode: 124
-				};
-			}
-		},
-		async readFile(sandboxId, path) {
-			return get(sandboxId).sandbox.files.read(path);
-		},
-		async writeFile(sandboxId, path, content, encoding = "utf-8") {
-			const data = typeof content === "string" ? encoding === "utf-8" || encoding === "utf8" ? content : Buffer.from(content, encoding) : content;
-			await get(sandboxId).sandbox.files.write(path, data);
-		},
-		async listFiles(sandboxId, path) {
-			return (await get(sandboxId).sandbox.files.list(path)).map((e) => e.type === "dir" ? `${e.name}/` : e.name);
-		},
-		async destroy(sandboxId) {
-			const entry = live.get(sandboxId);
-			if (!entry) return;
-			if (entry.owned) {
-				const action = options.onDestroy ?? "kill";
-				if (action === "pause") await pauseOwnedSandbox(entry.sandbox);
-				else if (action === "kill") await killOwnedSandbox(entry.sandbox);
-			}
-			live.delete(sandboxId);
-		}
-	};
-}
-//#endregion
-export { createE2BProvider, resolveE2BEnv, resolveE2BTemplate, runE2BPregame, waitForE2BReady };
-
-//# sourceMappingURL=e2b.js.map
+export { t as createE2BProvider, a as resolveE2BEnv, n as resolveE2BTemplate, r as runE2BPregame, i as waitForE2BReady } from "../e2b-CEVOdRib.js";

package/dist/contexts/sandbox.d.ts

@@ -1,2 +1,2 @@
-import { n as createSandboxContext, t as SandboxProvider } from "../sandbox-BH0WQkXn.js";
+import { n as createSandboxContext, t as SandboxProvider } from "../sandbox-C5dR5DwQ.js";
 export { SandboxProvider, createSandboxContext };

package/dist/contexts/sandbox.js

@@ -31,6 +31,11 @@ function createSandboxContext(provider) {
 			return provider.exec(getSandboxId(handle), command, options);
 		},
 		...provider.execStream ? { execStream: async (handle, command, options) => provider.execStream(getSandboxId(handle), command, options) } : {},
+		...provider.openTerminal ? { openTerminal: async (handle, options) => provider.openTerminal(getSandboxId(handle), {
+			...options,
+			cwd: options.cwd ?? handle.cwd
+		}) } : {},
+		...provider.reconnectTerminal ? { reconnectTerminal: async (handle, id, options) => provider.reconnectTerminal(getSandboxId(handle), id, options) } : {},
 		async readFile(handle, path) {
 			return provider.readFile(getSandboxId(handle), path);
 		},

package/dist/contexts/sandbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox.js","names":[],"sources":["../../src/contexts/sandbox.ts"],"sourcesContent":["/**\n * Remote sandbox execution context.\n *\n * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).\n * Specific providers implement the SandboxProvider interface.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, ListFilesOptions, SpawnConfig, StreamHandle } from './types'\nimport { fileSizeViaExec } from './exec-file-size'\nimport { globFilesViaShell } from './glob-shell'\n\n// ---------------------------------------------------------------------------\n// Sandbox provider interface\n// ---------------------------------------------------------------------------\n\nexport interface SandboxProvider {\n  name: string\n  spawn: (config: SpawnConfig) => Promise<{ id: string, cwd: string }>\n  exec: (sandboxId: string, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }) => Promise<ExecResult>\n  readFile: (sandboxId: string, path: string) => Promise<string>\n  writeFile: (sandboxId: string, path: string, content: string | Buffer, encoding?: BufferEncoding) => Promise<void>\n  listFiles: (sandboxId: string, path: string, options?: ListFilesOptions) => Promise<string[]>\n  destroy: (sandboxId: string) => Promise<void>\n  /**\n   * Optional live bidirectional stream — see {@link ExecutionContext.execStream}\n   * for the implementor contract. Providers whose backing API has no stdin\n   * channel omit it; `createSandboxContext` then leaves `execStream` off the\n   * context entirely so `capabilities.stream` stays false and callers get a\n   * clear \"unsupported\" error instead of a silent host spawn.\n   */\n  execStream?: (\n    sandboxId: string,\n    command: string,\n    options?: { cwd?: string, env?: Record<string, string>, signal?: AbortSignal },\n  ) => Promise<StreamHandle>\n}\n\n// ---------------------------------------------------------------------------\n// Sandbox execution context\n// ---------------------------------------------------------------------------\n\nexport function createSandboxContext(provider: SandboxProvider): ExecutionContext {\n  const sandboxes = new Map<string, string>()\n  const destroyed = new Set<string>()\n\n  // The handle id IS the sandbox id (set in `spawn` below), so the map is an\n  // identity record of sandboxes this context instance spawned. A handle this\n  // instance never spawned falls back to `handle.id` — the re-attach path for\n  // durable hosts that journal the handle and hand it back via\n  // `AgentOptions.handle` on a replay where `spawn` never re-ran. An\n  // EXPLICITLY-destroyed handle still throws (a use-after-free guard, distinct\n  // from never-spawned).\n  function getSandboxId(handle: ExecutionHandle): string {\n    if (destroyed.has(handle.id))\n      throw new Error(`Sandbox ${handle.id} not found`)\n    return sandboxes.get(handle.id) ?? handle.id\n  }\n\n  return {\n    type: 'sandbox',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      glob: true,\n      network: true,\n      gpu: false,\n      stream: provider.execStream !== undefined,\n    } satisfies ContextCapabilities,\n\n    async spawn(config?: SpawnConfig): Promise<ExecutionHandle> {\n      const result = await provider.spawn(config ?? {})\n      const handle: ExecutionHandle = { id: result.id, type: 'sandbox', cwd: result.cwd }\n      sandboxes.set(handle.id, result.id)\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?): Promise<ExecResult> {\n      return provider.exec(getSandboxId(handle), command, options)\n    },\n\n    // Conditionally present: `capabilities.stream` is derived from the\n    // provider, so the method must disappear too when the provider has no\n    // stdin channel. A stub that always throws would make the two disagree.\n    ...(provider.execStream\n      ? {\n          execStream: async (\n            handle: ExecutionHandle,\n            command: string,\n            options?: { cwd?: string, env?: Record<string, string>, signal?: AbortSignal },\n          ): Promise<StreamHandle> => provider.execStream!(getSandboxId(handle), command, options),\n        }\n      : {}),\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return provider.readFile(getSandboxId(handle), path)\n    },\n\n    async fileSize(handle: ExecutionHandle, path: string): Promise<number | null> {\n      // Shared exec-probed capability (see exec-file-size.ts). Probe\n      // through the sandbox's shell rather than the provider's file API:\n      // `readFile` buffers the WHOLE file into host memory, so the\n      // whole-read guard needs the size BEFORE any transfer happens. One\n      // exec round-trip per whole-read tool call (read_file / edit) — the\n      // price of not ballooning the host on a multi-GB sandbox file.\n      return fileSizeViaExec(command => provider.exec(getSandboxId(handle), command), path)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string | Buffer, encoding?: BufferEncoding): Promise<void> {\n      return provider.writeFile(getSandboxId(handle), path, content, encoding)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string, options?: ListFilesOptions): Promise<string[]> {\n      const sandboxId = getSandboxId(handle)\n      if (options?.glob) {\n        return globFilesViaShell(\n          path,\n          command => provider.exec(sandboxId, command, { cwd: handle.cwd }),\n          options?.limit ?? 1000,\n        )\n      }\n      return provider.listFiles(sandboxId, path, options)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const id = sandboxes.get(handle.id)\n      if (!id)\n        return\n      await provider.destroy(id)\n      sandboxes.delete(handle.id)\n      // Mark as torn down so a later op on this exact handle fails loudly\n      // (use-after-free) instead of silently re-attaching by id.\n      destroyed.add(handle.id)\n    },\n  }\n}\n"],"mappings":";;AA0CA,SAAgB,qBAAqB,UAA6C;CAChF,MAAM,4BAAY,IAAI,IAAoB;CAC1C,MAAM,4BAAY,IAAI,IAAY;CASlC,SAAS,aAAa,QAAiC;EACrD,IAAI,UAAU,IAAI,OAAO,EAAE,GACzB,MAAM,IAAI,MAAM,WAAW,OAAO,GAAG,WAAW;EAClD,OAAO,UAAU,IAAI,OAAO,EAAE,KAAK,OAAO;CAC5C;CAEA,OAAO;EACL,MAAM;EAEN,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,MAAM;GACN,SAAS;GACT,KAAK;GACL,QAAQ,SAAS,eAAe,KAAA;EAClC;EAEA,MAAM,MAAM,QAAgD;GAC1D,MAAM,SAAS,MAAM,SAAS,MAAM,UAAU,CAAC,CAAC;GAChD,MAAM,SAA0B;IAAE,IAAI,OAAO;IAAI,MAAM;IAAW,KAAK,OAAO;GAAI;GAClF,UAAU,IAAI,OAAO,IAAI,OAAO,EAAE;GAClC,OAAO;EACT;EAEA,MAAM,KAAK,QAAyB,SAAiB,SAA+B;GAClF,OAAO,SAAS,KAAK,aAAa,MAAM,GAAG,SAAS,OAAO;EAC7D;EAKA,GAAI,SAAS,aACT,EACE,YAAY,OACV,QACA,SACA,YAC0B,SAAS,WAAY,aAAa,MAAM,GAAG,SAAS,OAAO,EACzF,IACA,CAAC;EAEL,MAAM,SAAS,QAAyB,MAA+B;GACrE,OAAO,SAAS,SAAS,aAAa,MAAM,GAAG,IAAI;EACrD;EAEA,MAAM,SAAS,QAAyB,MAAsC;GAO5E,OAAO,iBAAgB,YAAW,SAAS,KAAK,aAAa,MAAM,GAAG,OAAO,GAAG,IAAI;EACtF;EAEA,MAAM,UAAU,QAAyB,MAAc,SAA0B,UAA0C;GACzH,OAAO,SAAS,UAAU,aAAa,MAAM,GAAG,MAAM,SAAS,QAAQ;EACzE;EAEA,MAAM,UAAU,QAAyB,MAAc,SAA+C;GACpG,MAAM,YAAY,aAAa,MAAM;GACrC,IAAI,SAAS,MACX,OAAO,kBACL,OACA,YAAW,SAAS,KAAK,WAAW,SAAS,EAAE,KAAK,OAAO,IAAI,CAAC,GAChE,SAAS,SAAS,GACpB;GAEF,OAAO,SAAS,UAAU,WAAW,MAAM,OAAO;EACpD;EAEA,MAAM,QAAQ,QAAwC;GACpD,MAAM,KAAK,UAAU,IAAI,OAAO,EAAE;GAClC,IAAI,CAAC,IACH;GACF,MAAM,SAAS,QAAQ,EAAE;GACzB,UAAU,OAAO,OAAO,EAAE;GAG1B,UAAU,IAAI,OAAO,EAAE;EACzB;CACF;AACF"}
+{"version":3,"file":"sandbox.js","names":[],"sources":["../../src/contexts/sandbox.ts"],"sourcesContent":["/**\n * Remote sandbox execution context.\n *\n * Offloads execution to a remote sandbox API (e.g. Rivet, E2B).\n * Specific providers implement the SandboxProvider interface.\n */\n\nimport type { Buffer } from 'node:buffer'\nimport type { ContextCapabilities, ExecResult, ExecutionContext, ExecutionHandle, ListFilesOptions, SpawnConfig, StreamHandle, TerminalOptions, TerminalProcess } from './types'\nimport { fileSizeViaExec } from './exec-file-size'\nimport { globFilesViaShell } from './glob-shell'\n\n// ---------------------------------------------------------------------------\n// Sandbox provider interface\n// ---------------------------------------------------------------------------\n\nexport interface SandboxProvider {\n  name: string\n  spawn: (config: SpawnConfig) => Promise<{ id: string, cwd: string }>\n  exec: (sandboxId: string, command: string, options?: { cwd?: string, env?: Record<string, string>, timeout?: number }) => Promise<ExecResult>\n  readFile: (sandboxId: string, path: string) => Promise<string>\n  writeFile: (sandboxId: string, path: string, content: string | Buffer, encoding?: BufferEncoding) => Promise<void>\n  listFiles: (sandboxId: string, path: string, options?: ListFilesOptions) => Promise<string[]>\n  destroy: (sandboxId: string) => Promise<void>\n  /**\n   * Optional live bidirectional stream — see {@link ExecutionContext.execStream}\n   * for the implementor contract. Providers whose backing API has no stdin\n   * channel omit it; `createSandboxContext` then leaves `execStream` off the\n   * context entirely so `capabilities.stream` stays false and callers get a\n   * clear \"unsupported\" error instead of a silent host spawn.\n   */\n  execStream?: (\n    sandboxId: string,\n    command: string,\n    options?: { cwd?: string, env?: Record<string, string>, signal?: AbortSignal },\n  ) => Promise<StreamHandle>\n  /** Optional interactive terminal — see {@link ExecutionContext.openTerminal}. */\n  openTerminal?: (sandboxId: string, options: TerminalOptions) => Promise<TerminalProcess>\n  /** Re-attach to a terminal by id — see {@link ExecutionContext.reconnectTerminal}. */\n  reconnectTerminal?: (sandboxId: string, id: string, options: TerminalOptions) => Promise<TerminalProcess | null>\n}\n\n// ---------------------------------------------------------------------------\n// Sandbox execution context\n// ---------------------------------------------------------------------------\n\nexport function createSandboxContext(provider: SandboxProvider): ExecutionContext {\n  const sandboxes = new Map<string, string>()\n  const destroyed = new Set<string>()\n\n  // The handle id IS the sandbox id (set in `spawn` below), so the map is an\n  // identity record of sandboxes this context instance spawned. A handle this\n  // instance never spawned falls back to `handle.id` — the re-attach path for\n  // durable hosts that journal the handle and hand it back via\n  // `AgentOptions.handle` on a replay where `spawn` never re-ran. An\n  // EXPLICITLY-destroyed handle still throws (a use-after-free guard, distinct\n  // from never-spawned).\n  function getSandboxId(handle: ExecutionHandle): string {\n    if (destroyed.has(handle.id))\n      throw new Error(`Sandbox ${handle.id} not found`)\n    return sandboxes.get(handle.id) ?? handle.id\n  }\n\n  return {\n    type: 'sandbox',\n\n    capabilities: {\n      shell: true,\n      filesystem: true,\n      glob: true,\n      network: true,\n      gpu: false,\n      stream: provider.execStream !== undefined,\n    } satisfies ContextCapabilities,\n\n    async spawn(config?: SpawnConfig): Promise<ExecutionHandle> {\n      const result = await provider.spawn(config ?? {})\n      const handle: ExecutionHandle = { id: result.id, type: 'sandbox', cwd: result.cwd }\n      sandboxes.set(handle.id, result.id)\n      return handle\n    },\n\n    async exec(handle: ExecutionHandle, command: string, options?): Promise<ExecResult> {\n      return provider.exec(getSandboxId(handle), command, options)\n    },\n\n    // Conditionally present: `capabilities.stream` is derived from the\n    // provider, so the method must disappear too when the provider has no\n    // stdin channel. A stub that always throws would make the two disagree.\n    ...(provider.execStream\n      ? {\n          execStream: async (\n            handle: ExecutionHandle,\n            command: string,\n            options?: { cwd?: string, env?: Record<string, string>, signal?: AbortSignal },\n          ): Promise<StreamHandle> => provider.execStream!(getSandboxId(handle), command, options),\n        }\n      : {}),\n\n    ...(provider.openTerminal\n      ? {\n          openTerminal: async (handle: ExecutionHandle, options: TerminalOptions): Promise<TerminalProcess> =>\n            provider.openTerminal!(getSandboxId(handle), { ...options, cwd: options.cwd ?? handle.cwd }),\n        }\n      : {}),\n    ...(provider.reconnectTerminal\n      ? {\n          reconnectTerminal: async (handle: ExecutionHandle, id: string, options: TerminalOptions): Promise<TerminalProcess | null> =>\n            provider.reconnectTerminal!(getSandboxId(handle), id, options),\n        }\n      : {}),\n\n    async readFile(handle: ExecutionHandle, path: string): Promise<string> {\n      return provider.readFile(getSandboxId(handle), path)\n    },\n\n    async fileSize(handle: ExecutionHandle, path: string): Promise<number | null> {\n      // Shared exec-probed capability (see exec-file-size.ts). Probe\n      // through the sandbox's shell rather than the provider's file API:\n      // `readFile` buffers the WHOLE file into host memory, so the\n      // whole-read guard needs the size BEFORE any transfer happens. One\n      // exec round-trip per whole-read tool call (read_file / edit) — the\n      // price of not ballooning the host on a multi-GB sandbox file.\n      return fileSizeViaExec(command => provider.exec(getSandboxId(handle), command), path)\n    },\n\n    async writeFile(handle: ExecutionHandle, path: string, content: string | Buffer, encoding?: BufferEncoding): Promise<void> {\n      return provider.writeFile(getSandboxId(handle), path, content, encoding)\n    },\n\n    async listFiles(handle: ExecutionHandle, path: string, options?: ListFilesOptions): Promise<string[]> {\n      const sandboxId = getSandboxId(handle)\n      if (options?.glob) {\n        return globFilesViaShell(\n          path,\n          command => provider.exec(sandboxId, command, { cwd: handle.cwd }),\n          options?.limit ?? 1000,\n        )\n      }\n      return provider.listFiles(sandboxId, path, options)\n    },\n\n    async destroy(handle: ExecutionHandle): Promise<void> {\n      const id = sandboxes.get(handle.id)\n      if (!id)\n        return\n      await provider.destroy(id)\n      sandboxes.delete(handle.id)\n      // Mark as torn down so a later op on this exact handle fails loudly\n      // (use-after-free) instead of silently re-attaching by id.\n      destroyed.add(handle.id)\n    },\n  }\n}\n"],"mappings":";;AA8CA,SAAgB,qBAAqB,UAA6C;CAChF,MAAM,4BAAY,IAAI,IAAoB;CAC1C,MAAM,4BAAY,IAAI,IAAY;CASlC,SAAS,aAAa,QAAiC;EACrD,IAAI,UAAU,IAAI,OAAO,EAAE,GACzB,MAAM,IAAI,MAAM,WAAW,OAAO,GAAG,WAAW;EAClD,OAAO,UAAU,IAAI,OAAO,EAAE,KAAK,OAAO;CAC5C;CAEA,OAAO;EACL,MAAM;EAEN,cAAc;GACZ,OAAO;GACP,YAAY;GACZ,MAAM;GACN,SAAS;GACT,KAAK;GACL,QAAQ,SAAS,eAAe,KAAA;EAClC;EAEA,MAAM,MAAM,QAAgD;GAC1D,MAAM,SAAS,MAAM,SAAS,MAAM,UAAU,CAAC,CAAC;GAChD,MAAM,SAA0B;IAAE,IAAI,OAAO;IAAI,MAAM;IAAW,KAAK,OAAO;GAAI;GAClF,UAAU,IAAI,OAAO,IAAI,OAAO,EAAE;GAClC,OAAO;EACT;EAEA,MAAM,KAAK,QAAyB,SAAiB,SAA+B;GAClF,OAAO,SAAS,KAAK,aAAa,MAAM,GAAG,SAAS,OAAO;EAC7D;EAKA,GAAI,SAAS,aACT,EACE,YAAY,OACV,QACA,SACA,YAC0B,SAAS,WAAY,aAAa,MAAM,GAAG,SAAS,OAAO,EACzF,IACA,CAAC;EAEL,GAAI,SAAS,eACT,EACE,cAAc,OAAO,QAAyB,YAC5C,SAAS,aAAc,aAAa,MAAM,GAAG;GAAE,GAAG;GAAS,KAAK,QAAQ,OAAO,OAAO;EAAI,CAAC,EAC/F,IACA,CAAC;EACL,GAAI,SAAS,oBACT,EACE,mBAAmB,OAAO,QAAyB,IAAY,YAC7D,SAAS,kBAAmB,aAAa,MAAM,GAAG,IAAI,OAAO,EACjE,IACA,CAAC;EAEL,MAAM,SAAS,QAAyB,MAA+B;GACrE,OAAO,SAAS,SAAS,aAAa,MAAM,GAAG,IAAI;EACrD;EAEA,MAAM,SAAS,QAAyB,MAAsC;GAO5E,OAAO,iBAAgB,YAAW,SAAS,KAAK,aAAa,MAAM,GAAG,OAAO,GAAG,IAAI;EACtF;EAEA,MAAM,UAAU,QAAyB,MAAc,SAA0B,UAA0C;GACzH,OAAO,SAAS,UAAU,aAAa,MAAM,GAAG,MAAM,SAAS,QAAQ;EACzE;EAEA,MAAM,UAAU,QAAyB,MAAc,SAA+C;GACpG,MAAM,YAAY,aAAa,MAAM;GACrC,IAAI,SAAS,MACX,OAAO,kBACL,OACA,YAAW,SAAS,KAAK,WAAW,SAAS,EAAE,KAAK,OAAO,IAAI,CAAC,GAChE,SAAS,SAAS,GACpB;GAEF,OAAO,SAAS,UAAU,WAAW,MAAM,OAAO;EACpD;EAEA,MAAM,QAAQ,QAAwC;GACpD,MAAM,KAAK,UAAU,IAAI,OAAO,EAAE;GAClC,IAAI,CAAC,IACH;GACF,MAAM,SAAS,QAAQ,EAAE;GACzB,UAAU,OAAO,OAAO,EAAE;GAG1B,UAAU,IAAI,OAAO,EAAE;EACzB;CACF;AACF"}