@opencoredev/sandbox-sdk 0.1.0

package/dist/providers/upstash/index.mjs

@@ -0,0 +1,210 @@
+import { t as SandboxError } from "../../errors-Ch9PHKTd.mjs";
+import "../../capabilities-COKpwoFH.mjs";
+import "../../sandbox-BwyHcB_C.mjs";
+import { a as upstashCapabilities } from "../../capabilities-CEowrzRM.mjs";
+import { i as unsupported, n as portResult, o as withManagedSessions, r as toUint8Array, t as commandString } from "../../provider-utils-DilOYLBO.mjs";
+import { Box } from "@upstash/box";
+
+//#region src/providers/upstash/index.ts
+function upstash(options = {}) {
+	const { public: publicPorts = true, ...boxOptions } = options;
+	return withManagedSessions({
+		id: "upstash",
+		capabilities: upstashCapabilities,
+		async create(createOptions) {
+			assertNotAborted(createOptions.signal);
+			const raw = await Box.create({
+				...boxOptions,
+				env: { ...createOptions.env },
+				timeout: boxOptions.timeout ?? createOptions.timeout
+			});
+			const remoteCwd = raw.cwd;
+			const toRemotePath = (path) => replacePathPrefix(path, createOptions.cwd, remoteCwd);
+			const toVirtualPath = (path) => replacePathPrefix(path, remoteCwd, createOptions.cwd);
+			return {
+				id: raw.id,
+				raw,
+				capabilities: upstashCapabilities,
+				files: {
+					async write(path, value) {
+						const content = Buffer.from(await toUint8Array(value)).toString("base64");
+						await raw.files.write({
+							path: toRemotePath(path),
+							content,
+							encoding: "base64"
+						});
+					},
+					async read(path) {
+						const content = await raw.files.read(toRemotePath(path), { encoding: "base64" });
+						return new Uint8Array(Buffer.from(content, "base64"));
+					},
+					async list(path) {
+						return (await raw.files.list(toRemotePath(path))).map((entry) => ({
+							name: entry.name,
+							path: toVirtualPath(entry.path),
+							type: entry.is_dir ? "directory" : "file",
+							size: entry.size
+						}));
+					},
+					async mkdir(path) {
+						const result = await raw.exec.command(`mkdir -p ${shellQuote(toRemotePath(path))}`);
+						assertCommandSucceeded(result.exitCode, result.result, "files.mkdir");
+					},
+					async remove(path) {
+						const result = await raw.exec.command(`rm -rf -- ${shellQuote(toRemotePath(path))}`);
+						assertCommandSucceeded(result.exitCode, result.result, "files.remove");
+					},
+					async exists(path) {
+						return (await raw.exec.command(`test -e ${shellQuote(toRemotePath(path))}`)).exitCode === 0;
+					}
+				},
+				async run(command, runOptions) {
+					assertNotAborted(runOptions.signal);
+					const started = performance.now();
+					const run = await raw.exec.command(scopedCommand(command, runOptions, createOptions.cwd, remoteCwd));
+					if (runOptions.timeout !== void 0 && run.exitCode === 124) throw new SandboxError({
+						code: "timeout",
+						provider: "upstash",
+						operation: "process.run",
+						message: `Command timed out after ${runOptions.timeout}ms`
+					});
+					return {
+						stdout: run.result,
+						stderr: "",
+						exitCode: run.exitCode ?? 1,
+						success: run.exitCode === 0,
+						durationMs: Math.round(performance.now() - started)
+					};
+				},
+				async start(command, runOptions) {
+					assertNotAborted(runOptions.signal);
+					const handle = await raw.exec.stream(scopedCommand(command, runOptions, createOptions.cwd, remoteCwd));
+					const events = [];
+					const waiters = /* @__PURE__ */ new Set();
+					let status = "running";
+					let exitCode = 1;
+					const wake = () => {
+						for (const waiter of waiters) waiter();
+						waiters.clear();
+					};
+					const streamCompleted = consumeStream(handle, (chunk) => {
+						if (chunk.type === "output") {
+							events.push({
+								stream: "stdout",
+								data: chunk.data,
+								timestamp: /* @__PURE__ */ new Date()
+							});
+							wake();
+						} else exitCode = chunk.exitCode;
+					}).then(() => {
+						if (status === "running") status = "exited";
+						return { exitCode };
+					}).catch((error) => {
+						status = "exited";
+						throw error;
+					}).finally(() => {
+						wake();
+					});
+					return {
+						id: handle.id,
+						async status() {
+							return status;
+						},
+						async *output() {
+							let index = 0;
+							while (status === "running" || index < events.length) {
+								while (index < events.length) yield events[index++];
+								if (status !== "running") break;
+								await new Promise((resolve) => waiters.add(resolve));
+							}
+						},
+						async write() {
+							unsupported("upstash", "process.stdin");
+						},
+						wait: () => streamCompleted,
+						async kill() {
+							unsupported("upstash", "process.cancel");
+						}
+					};
+				},
+				async expose(port) {
+					const preview = await raw.getPublicURL(port, publicPorts ? void 0 : { bearerToken: true });
+					const token = preview.token;
+					return portResult(port, preview.url, !token, Boolean(token), token ? (path = "/", init = {}) => fetch(new URL(path, preview.url), {
+						...init,
+						headers: {
+							...Object.fromEntries(new Headers(init.headers)),
+							authorization: `Bearer ${token}`
+						}
+					}) : void 0);
+				},
+				snapshots: {
+					async create(snapshotOptions) {
+						const snapshot = await raw.snapshot({ name: snapshotOptions?.name ?? `sandbox-sdk-${Date.now()}` });
+						return {
+							id: snapshot.id,
+							name: snapshot.name,
+							mode: "filesystem",
+							createdAt: timestamp(snapshot.created_at)
+						};
+					},
+					async delete(snapshot) {
+						await raw.deleteSnapshot(typeof snapshot === "string" ? snapshot : snapshot.id);
+					},
+					async restore() {
+						unsupported("upstash", "snapshot.restore");
+					}
+				},
+				async stop() {
+					await raw.delete();
+				}
+			};
+		}
+	}, [], {
+		stop: (sandbox) => sandbox.raw.pause(),
+		resume: (sandbox) => sandbox.raw.resume(),
+		destroy: (sandbox) => sandbox.raw.delete(),
+		setNetworkPolicy: (sandbox, policy) => sandbox.raw.updateNetworkPolicy(networkPolicy(policy))
+	});
+}
+async function consumeStream(stream, onChunk) {
+	for await (const chunk of stream) onChunk(chunk);
+}
+function scopedCommand(input, options, virtualCwd, remoteCwd) {
+	const environment = Object.entries(options.env ?? {}).map(([key, value]) => shellQuote(`${key}=${value}`));
+	const shell = `sh -c ${shellQuote(commandString(input))}`;
+	const timed = options.timeout ? `timeout ${Math.max(1, Math.ceil(options.timeout / 1e3))}s ${shell}` : shell;
+	return `cd ${shellQuote(replacePathPrefix(options.cwd ?? virtualCwd, virtualCwd, remoteCwd))} && ${environment.length ? `env ${environment.join(" ")} ` : ""}${timed} 2>&1`;
+}
+function replacePathPrefix(path, from, to) {
+	if (path === from) return to;
+	if (path.startsWith(`${from}/`)) return `${to}${path.slice(from.length)}`;
+	return path;
+}
+function shellQuote(value) {
+	return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function assertNotAborted(signal) {
+	if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+function assertCommandSucceeded(exitCode, output, operation) {
+	if (exitCode === 0) return;
+	throw new Error(`${operation} failed${output ? `: ${output}` : ""}`);
+}
+function timestamp(value) {
+	return new Date(value < 0xe8d4a51000 ? value * 1e3 : value);
+}
+function networkPolicy(policy) {
+	if (policy.mode === "allow-all" || policy.mode === "deny-all") return { mode: policy.mode };
+	if (policy.mode === "native") return policy.value;
+	return {
+		mode: "custom",
+		allowedDomains: [...policy.allowedHosts ?? []],
+		allowedCidrs: [...policy.allowedCIDRs ?? []],
+		deniedCidrs: [...policy.deniedCIDRs ?? []]
+	};
+}
+
+//#endregion
+export { upstash, upstashCapabilities };
+//# sourceMappingURL=index.mjs.map

package/dist/providers/upstash/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["events: ProcessOutputEvent[]","status: \"running\" | \"exited\""],"sources":["../../../src/providers/upstash/index.ts"],"sourcesContent":["import { Box, type BoxConfig, type ExecStreamChunk } from \"@upstash/box\";\nimport { SandboxError } from \"../../core/errors\";\nimport type { SandboxNetworkPolicy, SandboxProvider } from \"../../core/provider\";\nimport type {\n  CommandInput,\n  ProcessOutputEvent,\n  RunOptions,\n  SandboxProcess,\n  SandboxSnapshot,\n} from \"../../core/types\";\nimport { withManagedSessions } from \"../../internal/managed-provider\";\nimport {\n  commandString,\n  portResult,\n  toUint8Array,\n  unsupported,\n} from \"../../internal/provider-utils\";\nimport { upstashCapabilities } from \"../capabilities\";\n\nexport type UpstashOptions = Omit<BoxConfig, \"env\"> & {\n  /** Expose ports publicly. Set to false to return bearer-token URLs. */\n  public?: boolean;\n};\n\nexport { upstashCapabilities } from \"../capabilities\";\n\nexport function upstash(options: UpstashOptions = {}): SandboxProvider<Box> {\n  const { public: publicPorts = true, ...boxOptions } = options;\n\n  return withManagedSessions(\n    {\n      id: \"upstash\",\n      capabilities: upstashCapabilities,\n      async create(createOptions) {\n        assertNotAborted(createOptions.signal);\n        const raw = await Box.create({\n          ...boxOptions,\n          env: { ...createOptions.env },\n          timeout: boxOptions.timeout ?? createOptions.timeout,\n        });\n        const remoteCwd = raw.cwd;\n        const toRemotePath = (path: string) =>\n          replacePathPrefix(path, createOptions.cwd, remoteCwd);\n        const toVirtualPath = (path: string) =>\n          replacePathPrefix(path, remoteCwd, createOptions.cwd);\n\n        return {\n          id: raw.id,\n          raw,\n          capabilities: upstashCapabilities,\n          files: {\n            async write(path, value) {\n              const content = Buffer.from(await toUint8Array(value)).toString(\"base64\");\n              await raw.files.write({\n                path: toRemotePath(path),\n                content,\n                encoding: \"base64\",\n              });\n            },\n            async read(path) {\n              const content = await raw.files.read(toRemotePath(path), {\n                encoding: \"base64\",\n              });\n              return new Uint8Array(Buffer.from(content, \"base64\"));\n            },\n            async list(path) {\n              return (await raw.files.list(toRemotePath(path))).map((entry) => ({\n                name: entry.name,\n                path: toVirtualPath(entry.path),\n                type: entry.is_dir ? (\"directory\" as const) : (\"file\" as const),\n                size: entry.size,\n              }));\n            },\n            async mkdir(path) {\n              const result = await raw.exec.command(`mkdir -p ${shellQuote(toRemotePath(path))}`);\n              assertCommandSucceeded(result.exitCode, result.result, \"files.mkdir\");\n            },\n            async remove(path) {\n              const result = await raw.exec.command(`rm -rf -- ${shellQuote(toRemotePath(path))}`);\n              assertCommandSucceeded(result.exitCode, result.result, \"files.remove\");\n            },\n            async exists(path) {\n              const result = await raw.exec.command(`test -e ${shellQuote(toRemotePath(path))}`);\n              return result.exitCode === 0;\n            },\n          },\n          async run(command, runOptions) {\n            assertNotAborted(runOptions.signal);\n            const started = performance.now();\n            const run = await raw.exec.command(\n              scopedCommand(command, runOptions, createOptions.cwd, remoteCwd),\n            );\n            if (runOptions.timeout !== undefined && run.exitCode === 124) {\n              throw new SandboxError({\n                code: \"timeout\",\n                provider: \"upstash\",\n                operation: \"process.run\",\n                message: `Command timed out after ${runOptions.timeout}ms`,\n              });\n            }\n            return {\n              stdout: run.result,\n              stderr: \"\",\n              exitCode: run.exitCode ?? 1,\n              success: run.exitCode === 0,\n              durationMs: Math.round(performance.now() - started),\n            };\n          },\n          async start(command, runOptions) {\n            assertNotAborted(runOptions.signal);\n            const handle = await raw.exec.stream(\n              scopedCommand(command, runOptions, createOptions.cwd, remoteCwd),\n            );\n            const events: ProcessOutputEvent[] = [];\n            const waiters = new Set<() => void>();\n            let status: \"running\" | \"exited\" = \"running\";\n            let exitCode = 1;\n            const wake = () => {\n              for (const waiter of waiters) waiter();\n              waiters.clear();\n            };\n            const streamCompleted = consumeStream(handle, (chunk) => {\n              if (chunk.type === \"output\") {\n                events.push({\n                  stream: \"stdout\",\n                  data: chunk.data,\n                  timestamp: new Date(),\n                });\n                wake();\n              } else {\n                exitCode = chunk.exitCode;\n              }\n            })\n              .then(() => {\n                if (status === \"running\") status = \"exited\";\n                return { exitCode };\n              })\n              .catch((error: unknown) => {\n                status = \"exited\";\n                throw error;\n              })\n              .finally(() => {\n                wake();\n              });\n\n            return {\n              id: handle.id,\n              async status() {\n                return status;\n              },\n              async *output() {\n                let index = 0;\n                while (status === \"running\" || index < events.length) {\n                  while (index < events.length) yield events[index++]!;\n                  if (status !== \"running\") break;\n                  await new Promise<void>((resolve) => waiters.add(resolve));\n                }\n              },\n              async write() {\n                unsupported(\"upstash\", \"process.stdin\");\n              },\n              wait: () => streamCompleted,\n              async kill() {\n                unsupported(\"upstash\", \"process.cancel\");\n              },\n            } satisfies SandboxProcess;\n          },\n          async expose(port) {\n            const preview = await raw.getPublicURL(\n              port,\n              publicPorts ? undefined : { bearerToken: true },\n            );\n            const token = preview.token;\n            return portResult(\n              port,\n              preview.url,\n              !token,\n              Boolean(token),\n              token\n                ? (path = \"/\", init = {}) =>\n                    fetch(new URL(path, preview.url), {\n                      ...init,\n                      headers: {\n                        ...Object.fromEntries(new Headers(init.headers)),\n                        authorization: `Bearer ${token}`,\n                      },\n                    })\n                : undefined,\n            );\n          },\n          snapshots: {\n            async create(snapshotOptions) {\n              const snapshot = await raw.snapshot({\n                name: snapshotOptions?.name ?? `sandbox-sdk-${Date.now()}`,\n              });\n              return {\n                id: snapshot.id,\n                name: snapshot.name,\n                mode: \"filesystem\",\n                createdAt: timestamp(snapshot.created_at),\n              } satisfies SandboxSnapshot;\n            },\n            async delete(snapshot) {\n              await raw.deleteSnapshot(typeof snapshot === \"string\" ? snapshot : snapshot.id);\n            },\n            async restore() {\n              unsupported(\"upstash\", \"snapshot.restore\");\n            },\n          },\n          async stop() {\n            await raw.delete();\n          },\n        };\n      },\n    },\n    [],\n    {\n      stop: (sandbox) => sandbox.raw.pause(),\n      resume: (sandbox) => sandbox.raw.resume(),\n      destroy: (sandbox) => sandbox.raw.delete(),\n      setNetworkPolicy: (sandbox, policy) => sandbox.raw.updateNetworkPolicy(networkPolicy(policy)),\n    },\n  );\n}\n\nasync function consumeStream(\n  stream: AsyncIterable<ExecStreamChunk>,\n  onChunk: (chunk: ExecStreamChunk) => void,\n): Promise<void> {\n  for await (const chunk of stream) onChunk(chunk);\n}\n\nfunction scopedCommand(\n  input: CommandInput,\n  options: RunOptions,\n  virtualCwd: string,\n  remoteCwd: string,\n): string {\n  const environment = Object.entries(options.env ?? {}).map(([key, value]) =>\n    shellQuote(`${key}=${value}`),\n  );\n  const command = commandString(input);\n  const shell = `sh -c ${shellQuote(command)}`;\n  const timed = options.timeout\n    ? `timeout ${Math.max(1, Math.ceil(options.timeout / 1_000))}s ${shell}`\n    : shell;\n  const cwd = replacePathPrefix(options.cwd ?? virtualCwd, virtualCwd, remoteCwd);\n  return `cd ${shellQuote(cwd)} && ${\n    environment.length ? `env ${environment.join(\" \")} ` : \"\"\n  }${timed} 2>&1`;\n}\n\nfunction replacePathPrefix(path: string, from: string, to: string): string {\n  if (path === from) return to;\n  if (path.startsWith(`${from}/`)) return `${to}${path.slice(from.length)}`;\n  return path;\n}\n\nfunction shellQuote(value: string): string {\n  return `'${value.replaceAll(\"'\", `'\"'\"'`)}'`;\n}\n\nfunction assertNotAborted(signal?: AbortSignal): void {\n  if (signal?.aborted) throw signal.reason ?? new DOMException(\"Aborted\", \"AbortError\");\n}\n\nfunction assertCommandSucceeded(exitCode: number | null, output: string, operation: string): void {\n  if (exitCode === 0) return;\n  throw new Error(`${operation} failed${output ? `: ${output}` : \"\"}`);\n}\n\nfunction timestamp(value: number): Date {\n  return new Date(value < 1_000_000_000_000 ? value * 1_000 : value);\n}\n\nfunction networkPolicy(policy: SandboxNetworkPolicy): import(\"@upstash/box\").NetworkPolicy {\n  if (policy.mode === \"allow-all\" || policy.mode === \"deny-all\") return { mode: policy.mode };\n  if (policy.mode === \"native\") return policy.value as import(\"@upstash/box\").NetworkPolicy;\n  return {\n    mode: \"custom\",\n    allowedDomains: [...(policy.allowedHosts ?? [])],\n    allowedCidrs: [...(policy.allowedCIDRs ?? [])],\n    deniedCidrs: [...(policy.deniedCIDRs ?? [])],\n  };\n}\n\nexport type UpstashBox = Box;\n"],"mappings":";;;;;;;;AA0BA,SAAgB,QAAQ,UAA0B,EAAE,EAAwB;CAC1E,MAAM,EAAE,QAAQ,cAAc,MAAM,GAAG,eAAe;AAEtD,QAAO,oBACL;EACE,IAAI;EACJ,cAAc;EACd,MAAM,OAAO,eAAe;AAC1B,oBAAiB,cAAc,OAAO;GACtC,MAAM,MAAM,MAAM,IAAI,OAAO;IAC3B,GAAG;IACH,KAAK,EAAE,GAAG,cAAc,KAAK;IAC7B,SAAS,WAAW,WAAW,cAAc;IAC9C,CAAC;GACF,MAAM,YAAY,IAAI;GACtB,MAAM,gBAAgB,SACpB,kBAAkB,MAAM,cAAc,KAAK,UAAU;GACvD,MAAM,iBAAiB,SACrB,kBAAkB,MAAM,WAAW,cAAc,IAAI;AAEvD,UAAO;IACL,IAAI,IAAI;IACR;IACA,cAAc;IACd,OAAO;KACL,MAAM,MAAM,MAAM,OAAO;MACvB,MAAM,UAAU,OAAO,KAAK,MAAM,aAAa,MAAM,CAAC,CAAC,SAAS,SAAS;AACzE,YAAM,IAAI,MAAM,MAAM;OACpB,MAAM,aAAa,KAAK;OACxB;OACA,UAAU;OACX,CAAC;;KAEJ,MAAM,KAAK,MAAM;MACf,MAAM,UAAU,MAAM,IAAI,MAAM,KAAK,aAAa,KAAK,EAAE,EACvD,UAAU,UACX,CAAC;AACF,aAAO,IAAI,WAAW,OAAO,KAAK,SAAS,SAAS,CAAC;;KAEvD,MAAM,KAAK,MAAM;AACf,cAAQ,MAAM,IAAI,MAAM,KAAK,aAAa,KAAK,CAAC,EAAE,KAAK,WAAW;OAChE,MAAM,MAAM;OACZ,MAAM,cAAc,MAAM,KAAK;OAC/B,MAAM,MAAM,SAAU,cAAyB;OAC/C,MAAM,MAAM;OACb,EAAE;;KAEL,MAAM,MAAM,MAAM;MAChB,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ,YAAY,WAAW,aAAa,KAAK,CAAC,GAAG;AACnF,6BAAuB,OAAO,UAAU,OAAO,QAAQ,cAAc;;KAEvE,MAAM,OAAO,MAAM;MACjB,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ,aAAa,WAAW,aAAa,KAAK,CAAC,GAAG;AACpF,6BAAuB,OAAO,UAAU,OAAO,QAAQ,eAAe;;KAExE,MAAM,OAAO,MAAM;AAEjB,cADe,MAAM,IAAI,KAAK,QAAQ,WAAW,WAAW,aAAa,KAAK,CAAC,GAAG,EACpE,aAAa;;KAE9B;IACD,MAAM,IAAI,SAAS,YAAY;AAC7B,sBAAiB,WAAW,OAAO;KACnC,MAAM,UAAU,YAAY,KAAK;KACjC,MAAM,MAAM,MAAM,IAAI,KAAK,QACzB,cAAc,SAAS,YAAY,cAAc,KAAK,UAAU,CACjE;AACD,SAAI,WAAW,YAAY,UAAa,IAAI,aAAa,IACvD,OAAM,IAAI,aAAa;MACrB,MAAM;MACN,UAAU;MACV,WAAW;MACX,SAAS,2BAA2B,WAAW,QAAQ;MACxD,CAAC;AAEJ,YAAO;MACL,QAAQ,IAAI;MACZ,QAAQ;MACR,UAAU,IAAI,YAAY;MAC1B,SAAS,IAAI,aAAa;MAC1B,YAAY,KAAK,MAAM,YAAY,KAAK,GAAG,QAAQ;MACpD;;IAEH,MAAM,MAAM,SAAS,YAAY;AAC/B,sBAAiB,WAAW,OAAO;KACnC,MAAM,SAAS,MAAM,IAAI,KAAK,OAC5B,cAAc,SAAS,YAAY,cAAc,KAAK,UAAU,CACjE;KACD,MAAMA,SAA+B,EAAE;KACvC,MAAM,0BAAU,IAAI,KAAiB;KACrC,IAAIC,SAA+B;KACnC,IAAI,WAAW;KACf,MAAM,aAAa;AACjB,WAAK,MAAM,UAAU,QAAS,SAAQ;AACtC,cAAQ,OAAO;;KAEjB,MAAM,kBAAkB,cAAc,SAAS,UAAU;AACvD,UAAI,MAAM,SAAS,UAAU;AAC3B,cAAO,KAAK;QACV,QAAQ;QACR,MAAM,MAAM;QACZ,2BAAW,IAAI,MAAM;QACtB,CAAC;AACF,aAAM;YAEN,YAAW,MAAM;OAEnB,CACC,WAAW;AACV,UAAI,WAAW,UAAW,UAAS;AACnC,aAAO,EAAE,UAAU;OACnB,CACD,OAAO,UAAmB;AACzB,eAAS;AACT,YAAM;OACN,CACD,cAAc;AACb,YAAM;OACN;AAEJ,YAAO;MACL,IAAI,OAAO;MACX,MAAM,SAAS;AACb,cAAO;;MAET,OAAO,SAAS;OACd,IAAI,QAAQ;AACZ,cAAO,WAAW,aAAa,QAAQ,OAAO,QAAQ;AACpD,eAAO,QAAQ,OAAO,OAAQ,OAAM,OAAO;AAC3C,YAAI,WAAW,UAAW;AAC1B,cAAM,IAAI,SAAe,YAAY,QAAQ,IAAI,QAAQ,CAAC;;;MAG9D,MAAM,QAAQ;AACZ,mBAAY,WAAW,gBAAgB;;MAEzC,YAAY;MACZ,MAAM,OAAO;AACX,mBAAY,WAAW,iBAAiB;;MAE3C;;IAEH,MAAM,OAAO,MAAM;KACjB,MAAM,UAAU,MAAM,IAAI,aACxB,MACA,cAAc,SAAY,EAAE,aAAa,MAAM,CAChD;KACD,MAAM,QAAQ,QAAQ;AACtB,YAAO,WACL,MACA,QAAQ,KACR,CAAC,OACD,QAAQ,MAAM,EACd,SACK,OAAO,KAAK,OAAO,EAAE,KACpB,MAAM,IAAI,IAAI,MAAM,QAAQ,IAAI,EAAE;MAChC,GAAG;MACH,SAAS;OACP,GAAG,OAAO,YAAY,IAAI,QAAQ,KAAK,QAAQ,CAAC;OAChD,eAAe,UAAU;OAC1B;MACF,CAAC,GACJ,OACL;;IAEH,WAAW;KACT,MAAM,OAAO,iBAAiB;MAC5B,MAAM,WAAW,MAAM,IAAI,SAAS,EAClC,MAAM,iBAAiB,QAAQ,eAAe,KAAK,KAAK,IACzD,CAAC;AACF,aAAO;OACL,IAAI,SAAS;OACb,MAAM,SAAS;OACf,MAAM;OACN,WAAW,UAAU,SAAS,WAAW;OAC1C;;KAEH,MAAM,OAAO,UAAU;AACrB,YAAM,IAAI,eAAe,OAAO,aAAa,WAAW,WAAW,SAAS,GAAG;;KAEjF,MAAM,UAAU;AACd,kBAAY,WAAW,mBAAmB;;KAE7C;IACD,MAAM,OAAO;AACX,WAAM,IAAI,QAAQ;;IAErB;;EAEJ,EACD,EAAE,EACF;EACE,OAAO,YAAY,QAAQ,IAAI,OAAO;EACtC,SAAS,YAAY,QAAQ,IAAI,QAAQ;EACzC,UAAU,YAAY,QAAQ,IAAI,QAAQ;EAC1C,mBAAmB,SAAS,WAAW,QAAQ,IAAI,oBAAoB,cAAc,OAAO,CAAC;EAC9F,CACF;;AAGH,eAAe,cACb,QACA,SACe;AACf,YAAW,MAAM,SAAS,OAAQ,SAAQ,MAAM;;AAGlD,SAAS,cACP,OACA,SACA,YACA,WACQ;CACR,MAAM,cAAc,OAAO,QAAQ,QAAQ,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,WAC/D,WAAW,GAAG,IAAI,GAAG,QAAQ,CAC9B;CAED,MAAM,QAAQ,SAAS,WADP,cAAc,MAAM,CACM;CAC1C,MAAM,QAAQ,QAAQ,UAClB,WAAW,KAAK,IAAI,GAAG,KAAK,KAAK,QAAQ,UAAU,IAAM,CAAC,CAAC,IAAI,UAC/D;AAEJ,QAAO,MAAM,WADD,kBAAkB,QAAQ,OAAO,YAAY,YAAY,UAAU,CACnD,CAAC,MAC3B,YAAY,SAAS,OAAO,YAAY,KAAK,IAAI,CAAC,KAAK,KACtD,MAAM;;AAGX,SAAS,kBAAkB,MAAc,MAAc,IAAoB;AACzE,KAAI,SAAS,KAAM,QAAO;AAC1B,KAAI,KAAK,WAAW,GAAG,KAAK,GAAG,CAAE,QAAO,GAAG,KAAK,KAAK,MAAM,KAAK,OAAO;AACvE,QAAO;;AAGT,SAAS,WAAW,OAAuB;AACzC,QAAO,IAAI,MAAM,WAAW,KAAK,QAAQ,CAAC;;AAG5C,SAAS,iBAAiB,QAA4B;AACpD,KAAI,QAAQ,QAAS,OAAM,OAAO,UAAU,IAAI,aAAa,WAAW,aAAa;;AAGvF,SAAS,uBAAuB,UAAyB,QAAgB,WAAyB;AAChG,KAAI,aAAa,EAAG;AACpB,OAAM,IAAI,MAAM,GAAG,UAAU,SAAS,SAAS,KAAK,WAAW,KAAK;;AAGtE,SAAS,UAAU,OAAqB;AACtC,QAAO,IAAI,KAAK,QAAQ,eAAoB,QAAQ,MAAQ,MAAM;;AAGpE,SAAS,cAAc,QAAoE;AACzF,KAAI,OAAO,SAAS,eAAe,OAAO,SAAS,WAAY,QAAO,EAAE,MAAM,OAAO,MAAM;AAC3F,KAAI,OAAO,SAAS,SAAU,QAAO,OAAO;AAC5C,QAAO;EACL,MAAM;EACN,gBAAgB,CAAC,GAAI,OAAO,gBAAgB,EAAE,CAAE;EAChD,cAAc,CAAC,GAAI,OAAO,gBAAgB,EAAE,CAAE;EAC9C,aAAa,CAAC,GAAI,OAAO,eAAe,EAAE,CAAE;EAC7C"}

package/dist/providers/vercel/index.d.mts

@@ -0,0 +1,27 @@
+import "../../types-BTagTtsp.mjs";
+import { o as SandboxProvider } from "../../provider-_caCV8kk.mjs";
+import "../../index-BMFkO6Fv.mjs";
+import "../../sandbox-BUYT-1C9.mjs";
+import { o as vercelCapabilities } from "../../capabilities-CMnszzpt.mjs";
+import { Sandbox as VercelSandbox } from "@vercel/sandbox";
+
+//#region src/providers/vercel/index.d.ts
+interface VercelBaseOptions {
+  runtime?: "node24" | "node22" | "node26" | "python3.13" | (string & {});
+  name?: string;
+  ports?: number[];
+  persistent?: boolean;
+}
+type VercelOptions = VercelBaseOptions & ({
+  token: string;
+  teamId: string;
+  projectId: string;
+} | {
+  token?: never;
+  teamId?: never;
+  projectId?: never;
+});
+declare function vercel(options?: VercelOptions): SandboxProvider<VercelSandbox>;
+//#endregion
+export { VercelOptions, type VercelSandbox, vercel, vercelCapabilities };
+//# sourceMappingURL=index.d.mts.map

package/dist/providers/vercel/index.mjs

@@ -0,0 +1,185 @@
+import { r as normalizeError, t as SandboxError } from "../../errors-Ch9PHKTd.mjs";
+import "../../capabilities-COKpwoFH.mjs";
+import "../../sandbox-BwyHcB_C.mjs";
+import { o as vercelCapabilities } from "../../capabilities-CEowrzRM.mjs";
+import { i as unsupported, n as portResult, o as withManagedSessions, r as toUint8Array } from "../../provider-utils-DilOYLBO.mjs";
+import { Sandbox, Snapshot } from "@vercel/sandbox";
+
+//#region src/providers/vercel/index.ts
+function vercel(options = {}) {
+	return withManagedSessions({
+		id: "vercel",
+		capabilities: vercelCapabilities,
+		async create(createOptions) {
+			const credentials = options.token && options.teamId && options.projectId ? {
+				token: options.token,
+				teamId: options.teamId,
+				projectId: options.projectId
+			} : {};
+			const exposed = new Set(options.ports ?? []);
+			const raw = await Sandbox.create({
+				...credentials,
+				runtime: options.runtime ?? "node24",
+				name: options.name,
+				ports: [...exposed],
+				persistent: options.persistent,
+				timeout: createOptions.timeout,
+				env: { ...createOptions.env },
+				signal: createOptions.signal
+			});
+			const snapshots = /* @__PURE__ */ new Map();
+			await raw.fs.mkdir(createOptions.cwd, { recursive: true });
+			return {
+				id: raw.name,
+				raw,
+				capabilities: vercelCapabilities,
+				files: {
+					async write(path, value) {
+						await raw.fs.writeFile(path, await toUint8Array(value));
+					},
+					async read(path) {
+						return new Uint8Array(await raw.fs.readFile(path));
+					},
+					async list(path) {
+						const entries = await raw.fs.readdir(path, { withFileTypes: true });
+						return Promise.all(entries.map(async (entry) => {
+							const entryPath = `${path.replace(/\/$/, "")}/${entry.name}`;
+							const info = await raw.fs.lstat(entryPath);
+							return {
+								name: entry.name,
+								path: entryPath,
+								type: entry.isFile() ? "file" : entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : "unknown",
+								size: entry.isFile() ? info.size : void 0
+							};
+						}));
+					},
+					async mkdir(path) {
+						await raw.fs.mkdir(path, { recursive: true });
+					},
+					async remove(path) {
+						await raw.fs.rm(path, {
+							recursive: true,
+							force: true
+						});
+					},
+					exists: (path) => raw.fs.exists(path)
+				},
+				async run(command, runOptions) {
+					try {
+						const result = await runCommand(raw, command, runOptions, false);
+						const [stdout, stderr] = await Promise.all([result.stdout({ signal: runOptions.signal }), result.stderr({ signal: runOptions.signal })]);
+						if (runOptions.timeout !== void 0 && result.exitCode === 137 && result.durationMs !== void 0 && result.durationMs >= runOptions.timeout) throw new SandboxError({
+							code: "timeout",
+							provider: "vercel",
+							operation: "process.run",
+							message: `Command timed out after ${runOptions.timeout}ms`
+						});
+						return {
+							stdout,
+							stderr,
+							exitCode: result.exitCode,
+							success: result.exitCode === 0,
+							durationMs: result.durationMs
+						};
+					} catch (error) {
+						throw normalizeError("vercel", "process.run", error);
+					}
+				},
+				async start(command, runOptions) {
+					const handle = await runCommand(raw, command, runOptions, true);
+					const events = [];
+					let running = true;
+					const stream = handle.logs({ signal: runOptions.signal });
+					const completed = handle.wait().then((result) => ({ exitCode: result.exitCode }));
+					return {
+						id: handle.cmdId,
+						async status() {
+							return running ? "running" : "exited";
+						},
+						async *output() {
+							try {
+								for await (const event of stream) {
+									const normalized = {
+										stream: event.stream,
+										data: event.data,
+										timestamp: /* @__PURE__ */ new Date()
+									};
+									events.push(normalized);
+									yield normalized;
+								}
+							} finally {
+								running = false;
+							}
+						},
+						async write() {
+							unsupported("vercel", "process.stdin");
+						},
+						wait: () => completed,
+						async kill(signal = "SIGTERM") {
+							await handle.kill(signal);
+							running = false;
+						}
+					};
+				},
+				async expose(port) {
+					if (!exposed.has(port)) {
+						exposed.add(port);
+						await raw.update({ ports: [...exposed] });
+					}
+					return portResult(port, raw.domain(port), true, false);
+				},
+				snapshots: {
+					async create() {
+						const snapshot = await raw.snapshot();
+						snapshots.set(snapshot.snapshotId, snapshot);
+						return {
+							id: snapshot.snapshotId,
+							mode: "filesystem",
+							createdAt: snapshot.createdAt
+						};
+					},
+					async delete(snapshot) {
+						const id = typeof snapshot === "string" ? snapshot : snapshot.id;
+						await (snapshots.get(id) ?? await Snapshot.get({
+							snapshotId: id,
+							...credentials
+						})).delete();
+						snapshots.delete(id);
+					},
+					async restore() {
+						unsupported("vercel", "snapshot.restore");
+					}
+				},
+				async stop() {
+					if (raw.status !== "stopped") await raw.stop();
+				}
+			};
+		}
+	}, options.ports, {
+		stop: async (sandbox) => {
+			await sandbox.raw.stop();
+		},
+		destroy: (sandbox) => sandbox.raw.delete(),
+		setPorts: (sandbox, ports, signal) => sandbox.raw.update({ ports: [...ports] }, { signal }),
+		setNetworkPolicy: (sandbox, policy) => sandbox.raw.update({ networkPolicy: policy.mode === "allow-all" || policy.mode === "deny-all" ? policy.mode : policy.mode === "native" ? policy.value : { allow: [...policy.allowedHosts ?? []] } })
+	});
+}
+async function runCommand(raw, input, options, detached) {
+	const command = typeof input === "string" ? {
+		command: "/bin/sh",
+		args: ["-lc", input]
+	} : input;
+	return raw.runCommand({
+		cmd: command.command,
+		args: [...command.args ?? []],
+		cwd: options.cwd,
+		env: { ...options.env },
+		signal: options.signal,
+		timeoutMs: options.timeout,
+		detached
+	});
+}
+
+//#endregion
+export { vercel, vercelCapabilities };
+//# sourceMappingURL=index.mjs.map

package/dist/providers/vercel/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["VercelSandbox","events: ProcessOutputEvent[]","VercelSnapshot"],"sources":["../../../src/providers/vercel/index.ts"],"sourcesContent":["import { Sandbox as VercelSandbox, Snapshot as VercelSnapshot } from \"@vercel/sandbox\";\nimport { normalizeError, SandboxError } from \"../../core/errors\";\nimport type { SandboxProvider } from \"../../core/provider\";\nimport type {\n  CommandInput,\n  ProcessOutputEvent,\n  SandboxProcess,\n  SandboxSnapshot,\n} from \"../../core/types\";\nimport { portResult, toUint8Array, unsupported } from \"../../internal/provider-utils\";\nimport { vercelCapabilities } from \"../capabilities\";\nimport { withManagedSessions } from \"../../internal/managed-provider\";\n\ninterface VercelBaseOptions {\n  runtime?: \"node24\" | \"node22\" | \"node26\" | \"python3.13\" | (string & {});\n  name?: string;\n  ports?: number[];\n  persistent?: boolean;\n}\n\nexport type VercelOptions = VercelBaseOptions &\n  (\n    | { token: string; teamId: string; projectId: string }\n    | { token?: never; teamId?: never; projectId?: never }\n  );\n\nexport { vercelCapabilities } from \"../capabilities\";\n\nexport function vercel(options: VercelOptions = {}): SandboxProvider<VercelSandbox> {\n  return withManagedSessions(\n    {\n      id: \"vercel\",\n      capabilities: vercelCapabilities,\n      async create(createOptions) {\n        const credentials =\n          options.token && options.teamId && options.projectId\n            ? {\n                token: options.token,\n                teamId: options.teamId,\n                projectId: options.projectId,\n              }\n            : {};\n        const exposed = new Set(options.ports ?? []);\n        const raw = await VercelSandbox.create({\n          ...credentials,\n          runtime: options.runtime ?? \"node24\",\n          name: options.name,\n          ports: [...exposed],\n          persistent: options.persistent,\n          timeout: createOptions.timeout,\n          env: { ...createOptions.env },\n          signal: createOptions.signal,\n        });\n        const snapshots = new Map<string, VercelSnapshot>();\n        await raw.fs.mkdir(createOptions.cwd, { recursive: true });\n        return {\n          id: raw.name,\n          raw,\n          capabilities: vercelCapabilities,\n          files: {\n            async write(path, value) {\n              await raw.fs.writeFile(path, await toUint8Array(value));\n            },\n            async read(path) {\n              return new Uint8Array(await raw.fs.readFile(path));\n            },\n            async list(path) {\n              const entries = await raw.fs.readdir(path, {\n                withFileTypes: true,\n              });\n              return Promise.all(\n                entries.map(async (entry) => {\n                  const entryPath = `${path.replace(/\\/$/, \"\")}/${entry.name}`;\n                  const info = await raw.fs.lstat(entryPath);\n                  return {\n                    name: entry.name,\n                    path: entryPath,\n                    type: entry.isFile()\n                      ? (\"file\" as const)\n                      : entry.isDirectory()\n                        ? (\"directory\" as const)\n                        : entry.isSymbolicLink()\n                          ? (\"symlink\" as const)\n                          : (\"unknown\" as const),\n                    size: entry.isFile() ? info.size : undefined,\n                  };\n                }),\n              );\n            },\n            async mkdir(path) {\n              await raw.fs.mkdir(path, { recursive: true });\n            },\n            async remove(path) {\n              await raw.fs.rm(path, { recursive: true, force: true });\n            },\n            exists: (path) => raw.fs.exists(path),\n          },\n          async run(command, runOptions) {\n            try {\n              const result = await runCommand(raw, command, runOptions, false);\n              const [stdout, stderr] = await Promise.all([\n                result.stdout({ signal: runOptions.signal }),\n                result.stderr({ signal: runOptions.signal }),\n              ]);\n              if (\n                runOptions.timeout !== undefined &&\n                result.exitCode === 137 &&\n                result.durationMs !== undefined &&\n                result.durationMs >= runOptions.timeout\n              ) {\n                throw new SandboxError({\n                  code: \"timeout\",\n                  provider: \"vercel\",\n                  operation: \"process.run\",\n                  message: `Command timed out after ${runOptions.timeout}ms`,\n                });\n              }\n              return {\n                stdout,\n                stderr,\n                exitCode: result.exitCode,\n                success: result.exitCode === 0,\n                durationMs: result.durationMs,\n              };\n            } catch (error) {\n              throw normalizeError(\"vercel\", \"process.run\", error);\n            }\n          },\n          async start(command, runOptions) {\n            const handle = await runCommand(raw, command, runOptions, true);\n            const events: ProcessOutputEvent[] = [];\n            let running = true;\n            const stream = handle.logs({ signal: runOptions.signal });\n            const completed = handle.wait().then((result) => ({ exitCode: result.exitCode }));\n            const process: SandboxProcess = {\n              id: handle.cmdId,\n              async status() {\n                return running ? \"running\" : \"exited\";\n              },\n              async *output() {\n                try {\n                  for await (const event of stream) {\n                    const normalized = {\n                      stream: event.stream,\n                      data: event.data,\n                      timestamp: new Date(),\n                    } satisfies ProcessOutputEvent;\n                    events.push(normalized);\n                    yield normalized;\n                  }\n                } finally {\n                  running = false;\n                }\n              },\n              async write() {\n                unsupported(\"vercel\", \"process.stdin\");\n              },\n              wait: () => completed,\n              async kill(signal = \"SIGTERM\") {\n                await handle.kill(signal as Parameters<typeof handle.kill>[0]);\n                running = false;\n              },\n            };\n            return process;\n          },\n          async expose(port) {\n            if (!exposed.has(port)) {\n              exposed.add(port);\n              await raw.update({ ports: [...exposed] });\n            }\n            const url = raw.domain(port);\n            return portResult(port, url, true, false);\n          },\n          snapshots: {\n            async create() {\n              const snapshot = await raw.snapshot();\n              snapshots.set(snapshot.snapshotId, snapshot);\n              return {\n                id: snapshot.snapshotId,\n                mode: \"filesystem\",\n                createdAt: snapshot.createdAt,\n              } satisfies SandboxSnapshot;\n            },\n            async delete(snapshot) {\n              const id = typeof snapshot === \"string\" ? snapshot : snapshot.id;\n              const native =\n                snapshots.get(id) ?? (await VercelSnapshot.get({ snapshotId: id, ...credentials }));\n              await native.delete();\n              snapshots.delete(id);\n            },\n            async restore() {\n              unsupported(\"vercel\", \"snapshot.restore\");\n            },\n          },\n          async stop() {\n            if (raw.status !== \"stopped\") await raw.stop();\n          },\n        };\n      },\n    },\n    options.ports,\n    {\n      stop: async (sandbox) => {\n        await sandbox.raw.stop();\n      },\n      destroy: (sandbox) => sandbox.raw.delete(),\n      setPorts: (sandbox, ports, signal) => sandbox.raw.update({ ports: [...ports] }, { signal }),\n      setNetworkPolicy: (sandbox, policy) =>\n        sandbox.raw.update({\n          networkPolicy:\n            policy.mode === \"allow-all\" || policy.mode === \"deny-all\"\n              ? policy.mode\n              : policy.mode === \"native\"\n                ? (policy.value as import(\"@vercel/sandbox\").NetworkPolicy)\n                : { allow: [...(policy.allowedHosts ?? [])] },\n        }),\n    },\n  );\n}\n\nasync function runCommand(\n  raw: VercelSandbox,\n  input: CommandInput,\n  options: import(\"../../core/types\").RunOptions,\n  detached: false,\n): Promise<import(\"@vercel/sandbox\").CommandFinished>;\nasync function runCommand(\n  raw: VercelSandbox,\n  input: CommandInput,\n  options: import(\"../../core/types\").RunOptions,\n  detached: true,\n): Promise<import(\"@vercel/sandbox\").Command>;\nasync function runCommand(\n  raw: VercelSandbox,\n  input: CommandInput,\n  options: import(\"../../core/types\").RunOptions,\n  detached: boolean,\n) {\n  const command = typeof input === \"string\" ? { command: \"/bin/sh\", args: [\"-lc\", input] } : input;\n  return raw.runCommand({\n    cmd: command.command,\n    args: [...(command.args ?? [])],\n    cwd: options.cwd,\n    env: { ...options.env },\n    signal: options.signal,\n    timeoutMs: options.timeout,\n    detached,\n  });\n}\n\nexport type { VercelSandbox };\n"],"mappings":"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"}

package/dist/sandbox-BUYT-1C9.d.mts

@@ -0,0 +1,17 @@
+import { f as Sandbox } from "./types-BTagTtsp.mjs";
+import { o as SandboxProvider } from "./provider-_caCV8kk.mjs";
+
+//#region src/core/sandbox.d.ts
+interface CreateSandboxOptions<TProvider extends SandboxProvider<unknown>> {
+  provider: TProvider;
+  cwd?: string;
+  env?: Readonly<Record<string, string>>;
+  timeout?: number;
+  signal?: AbortSignal;
+}
+type RawOf<TProvider> = TProvider extends SandboxProvider<infer TRaw> ? TRaw : never;
+declare function createSandbox<TProvider extends SandboxProvider<unknown>>(options: CreateSandboxOptions<TProvider>): Promise<Sandbox<RawOf<TProvider>>>;
+declare function withSandbox<TProvider extends SandboxProvider<unknown>, TResult>(options: CreateSandboxOptions<TProvider>, callback: (sandbox: Sandbox<RawOf<TProvider>>) => TResult | Promise<TResult>): Promise<TResult>;
+//#endregion
+export { createSandbox as n, withSandbox as r, CreateSandboxOptions as t };
+//# sourceMappingURL=sandbox-BUYT-1C9.d.mts.map

package/dist/sandbox-BwyHcB_C.mjs

@@ -0,0 +1,102 @@
+import { r as normalizeError, t as SandboxError } from "./errors-Ch9PHKTd.mjs";
+
+//#region src/core/sandbox.ts
+function validateCwd(cwd) {
+	if (!cwd.startsWith("/") || cwd.includes("\0")) throw new SandboxError({
+		code: "invalid_input",
+		provider: "core",
+		operation: "create",
+		message: "cwd must be an absolute path"
+	});
+	return cwd.replace(/\/$/, "") || "/";
+}
+function validatePath(cwd, value) {
+	if (!value || value.includes("\0") || value.split("/").includes("..")) throw new SandboxError({
+		code: "invalid_input",
+		provider: "core",
+		operation: "path",
+		message: `Invalid sandbox path: ${value}`
+	});
+	if (value.startsWith("/")) return value.replace(/\/{2,}/g, "/");
+	return `${cwd}/${value}`.replace(/\/{2,}/g, "/");
+}
+async function createSandbox(options) {
+	const cwd = validateCwd(options.cwd ?? "/workspace");
+	const env = options.env ?? {};
+	let runtime;
+	try {
+		runtime = await options.provider.create({
+			cwd,
+			env,
+			timeout: options.timeout,
+			signal: options.signal
+		});
+	} catch (error) {
+		throw normalizeError(options.provider.id, "sandbox.create", error);
+	}
+	let stopPromise;
+	const stop = async () => {
+		stopPromise ??= call("sandbox.stop", () => runtime.stop());
+		return stopPromise;
+	};
+	const call = async (operation, fn) => {
+		try {
+			return await fn();
+		} catch (error) {
+			throw normalizeError(options.provider.id, operation, error);
+		}
+	};
+	return {
+		id: runtime.id,
+		provider: options.provider.id,
+		cwd,
+		capabilities: runtime.capabilities,
+		raw: runtime.raw,
+		files: {
+			write: async (path, value) => call("files.write", () => runtime.files.write(validatePath(cwd, path), value)),
+			read: async (path) => call("files.read", () => runtime.files.read(validatePath(cwd, path))),
+			text: async (path) => new TextDecoder().decode(await call("files.read", () => runtime.files.read(validatePath(cwd, path)))),
+			list: async (path = ".") => call("files.list", () => runtime.files.list(path === "." ? cwd : validatePath(cwd, path))),
+			mkdir: async (path) => call("files.mkdir", () => runtime.files.mkdir(validatePath(cwd, path))),
+			remove: async (path) => call("files.remove", () => runtime.files.remove(validatePath(cwd, path))),
+			exists: async (path) => call("files.exists", () => runtime.files.exists(validatePath(cwd, path)))
+		},
+		processes: { start: (command, runOptions = {}) => call("process.start", () => runtime.start(command, normalizeRunOptions(cwd, runOptions))) },
+		ports: { expose: (port) => call("ports.expose", () => runtime.expose(port)) },
+		snapshots: {
+			create: (snapshotOptions) => call("snapshot.create", () => runtime.snapshots.create(snapshotOptions)),
+			delete: (snapshot) => call("snapshot.delete", () => runtime.snapshots.delete(snapshot)),
+			restore: (snapshot) => call("snapshot.restore", () => runtime.snapshots.restore(snapshot))
+		},
+		run: (command, runOptions = {}) => call("process.run", () => runtime.run(command, normalizeRunOptions(cwd, runOptions))),
+		stop
+	};
+}
+function normalizeRunOptions(cwd, options) {
+	return {
+		...options,
+		cwd: options.cwd ? validatePath(cwd, options.cwd) : cwd
+	};
+}
+async function withSandbox(options, callback) {
+	const sandbox = await createSandbox(options);
+	try {
+		const result = await callback(sandbox);
+		await sandbox.stop();
+		return result;
+	} catch (error) {
+		try {
+			await sandbox.stop();
+		} catch (cleanupError) {
+			if (error instanceof Error) Object.defineProperty(error, "cleanupError", {
+				value: cleanupError,
+				enumerable: false
+			});
+		}
+		throw error;
+	}
+}
+
+//#endregion
+export { withSandbox as n, createSandbox as t };
+//# sourceMappingURL=sandbox-BwyHcB_C.mjs.map

package/dist/sandbox-BwyHcB_C.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-BwyHcB_C.mjs","names":["stopPromise: Promise<void> | undefined"],"sources":["../src/core/sandbox.ts"],"sourcesContent":["import { normalizeError, SandboxError } from \"./errors\";\nimport type { SandboxProvider } from \"./provider\";\nimport type { FileValue, RunOptions, Sandbox } from \"./types\";\n\nexport interface CreateSandboxOptions<TProvider extends SandboxProvider<unknown>> {\n  provider: TProvider;\n  cwd?: string;\n  env?: Readonly<Record<string, string>>;\n  timeout?: number;\n  signal?: AbortSignal;\n}\n\ntype RawOf<TProvider> = TProvider extends SandboxProvider<infer TRaw> ? TRaw : never;\n\nfunction validateCwd(cwd: string): string {\n  if (!cwd.startsWith(\"/\") || cwd.includes(\"\\0\")) {\n    throw new SandboxError({\n      code: \"invalid_input\",\n      provider: \"core\",\n      operation: \"create\",\n      message: \"cwd must be an absolute path\",\n    });\n  }\n  return cwd.replace(/\\/$/, \"\") || \"/\";\n}\n\nfunction validatePath(cwd: string, value: string): string {\n  if (!value || value.includes(\"\\0\") || value.split(\"/\").includes(\"..\")) {\n    throw new SandboxError({\n      code: \"invalid_input\",\n      provider: \"core\",\n      operation: \"path\",\n      message: `Invalid sandbox path: ${value}`,\n    });\n  }\n  if (value.startsWith(\"/\")) return value.replace(/\\/{2,}/g, \"/\");\n  return `${cwd}/${value}`.replace(/\\/{2,}/g, \"/\");\n}\n\nexport async function createSandbox<TProvider extends SandboxProvider<unknown>>(\n  options: CreateSandboxOptions<TProvider>,\n): Promise<Sandbox<RawOf<TProvider>>> {\n  const cwd = validateCwd(options.cwd ?? \"/workspace\");\n  const env = options.env ?? {};\n  let runtime;\n  try {\n    runtime = await options.provider.create({\n      cwd,\n      env,\n      timeout: options.timeout,\n      signal: options.signal,\n    });\n  } catch (error) {\n    throw normalizeError(options.provider.id, \"sandbox.create\", error);\n  }\n  let stopPromise: Promise<void> | undefined;\n  const stop = async () => {\n    stopPromise ??= call(\"sandbox.stop\", () => runtime.stop());\n    return stopPromise;\n  };\n  const call = async <T>(operation: string, fn: () => Promise<T>): Promise<T> => {\n    try {\n      return await fn();\n    } catch (error) {\n      throw normalizeError(options.provider.id, operation, error);\n    }\n  };\n  return {\n    id: runtime.id,\n    provider: options.provider.id,\n    cwd,\n    capabilities: runtime.capabilities,\n    raw: runtime.raw as RawOf<TProvider>,\n    files: {\n      write: async (path: string, value: FileValue) =>\n        call(\"files.write\", () => runtime.files.write(validatePath(cwd, path), value)),\n      read: async (path: string) =>\n        call(\"files.read\", () => runtime.files.read(validatePath(cwd, path))),\n      text: async (path: string) =>\n        new TextDecoder().decode(\n          await call(\"files.read\", () => runtime.files.read(validatePath(cwd, path))),\n        ),\n      list: async (path = \".\") =>\n        call(\"files.list\", () => runtime.files.list(path === \".\" ? cwd : validatePath(cwd, path))),\n      mkdir: async (path: string) =>\n        call(\"files.mkdir\", () => runtime.files.mkdir(validatePath(cwd, path))),\n      remove: async (path: string) =>\n        call(\"files.remove\", () => runtime.files.remove(validatePath(cwd, path))),\n      exists: async (path: string) =>\n        call(\"files.exists\", () => runtime.files.exists(validatePath(cwd, path))),\n    },\n    processes: {\n      start: (command, runOptions = {}) =>\n        call(\"process.start\", () => runtime.start(command, normalizeRunOptions(cwd, runOptions))),\n    },\n    ports: { expose: (port) => call(\"ports.expose\", () => runtime.expose(port)) },\n    snapshots: {\n      create: (snapshotOptions) =>\n        call(\"snapshot.create\", () => runtime.snapshots.create(snapshotOptions)),\n      delete: (snapshot) => call(\"snapshot.delete\", () => runtime.snapshots.delete(snapshot)),\n      restore: (snapshot) => call(\"snapshot.restore\", () => runtime.snapshots.restore(snapshot)),\n    },\n    run: (command, runOptions = {}) =>\n      call(\"process.run\", () => runtime.run(command, normalizeRunOptions(cwd, runOptions))),\n    stop,\n  };\n}\n\nfunction normalizeRunOptions(cwd: string, options: RunOptions): RunOptions {\n  return { ...options, cwd: options.cwd ? validatePath(cwd, options.cwd) : cwd };\n}\n\nexport async function withSandbox<TProvider extends SandboxProvider<unknown>, TResult>(\n  options: CreateSandboxOptions<TProvider>,\n  callback: (sandbox: Sandbox<RawOf<TProvider>>) => TResult | Promise<TResult>,\n): Promise<TResult> {\n  const sandbox = await createSandbox(options);\n  try {\n    const result = await callback(sandbox);\n    await sandbox.stop();\n    return result;\n  } catch (error) {\n    try {\n      await sandbox.stop();\n    } catch (cleanupError) {\n      if (error instanceof Error) {\n        Object.defineProperty(error, \"cleanupError\", { value: cleanupError, enumerable: false });\n      }\n    }\n    throw error;\n  }\n}\n"],"mappings":"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"}

package/dist/testing/index.d.mts

@@ -0,0 +1,27 @@
+import "../types-BTagTtsp.mjs";
+import { o as SandboxProvider } from "../provider-_caCV8kk.mjs";
+import { t as CreateSandboxOptions } from "../sandbox-BUYT-1C9.mjs";
+
+//#region src/testing/conformance.d.ts
+declare const conformanceCases: readonly ["create and stop", "idempotent stop", "text files", "binary files", "directories", "relative paths", "invalid paths", "successful command", "stdout", "stderr", "nonzero exit", "timeout", "background process", "stdin", "ports", "snapshot create", "snapshot delete", "snapshot restore", "cleanup after failure"];
+interface ConformanceSubject<TProvider extends SandboxProvider<unknown>> {
+  create: CreateSandboxOptions<TProvider>;
+  commands: {
+    success: string;
+    stdout: string;
+    stderr: string;
+    nonzero: string;
+    timeout: string;
+    background: string;
+    stdin: string;
+  };
+}
+interface ConformanceResult {
+  name: (typeof conformanceCases)[number];
+  status: "passed" | "failed" | "skipped";
+  error?: unknown;
+}
+declare function runConformance<TProvider extends SandboxProvider<unknown>>(subject: ConformanceSubject<TProvider>): Promise<ConformanceResult[]>;
+//#endregion
+export { type ConformanceResult, type ConformanceSubject, conformanceCases, runConformance };
+//# sourceMappingURL=index.d.mts.map