@opencoredev/sandbox-sdk 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+## @opencoredev/sandbox-sdk@0.1.0
+
+### Initial release
+
+- Run one TypeScript sandbox API across Local, E2B, Daytona, Vercel Sandbox, and Upstash Box.
+- Use normalized files, commands, processes, ports, snapshots, and provider capabilities.
+- Integrate sandbox sessions with AI SDK, Harness, Eve, and Mastra.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenCore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+<p align="center">
+  <img alt="Sandbox SDK with supported provider logos" src="https://raw.githubusercontent.com/opencoredev/sandbox-sdk/main/Background-with-text.png" width="820" />
+</p>
+
+Run the same TypeScript sandbox code on Local, E2B, Daytona, Vercel Sandbox, or Upstash Box.
+
+## Install
+
+```bash
+bun add @opencoredev/sandbox-sdk
+```
+
+Node.js 22 or 24 is supported. Bun 1.3 or newer is also supported.
+
+## Providers
+
+| Provider                                                        | Runtime                 | Best for                               |
+| --------------------------------------------------------------- | ----------------------- | -------------------------------------- |
+| [Local](https://sandbox-sdk.app/docs/providers/local)           | AgentOS VM              | Development, CI, and self-hosting      |
+| [E2B](https://sandbox-sdk.app/docs/providers/e2b)               | Hosted Linux sandbox    | Coding agents and isolated jobs        |
+| [Daytona](https://sandbox-sdk.app/docs/providers/daytona)       | Cloud workspace         | Persistent projects and GPUs           |
+| [Vercel Sandbox](https://sandbox-sdk.app/docs/providers/vercel) | Hosted Linux sandbox    | Vercel workloads and previews          |
+| [Upstash Box](https://sandbox-sdk.app/docs/providers/upstash)   | Durable cloud container | Serverless agents and long-lived state |
+
+Local is included. Cloud providers use their official SDKs and credentials.
+
+## Documentation
+
+Setup, usage, integrations, and API reference are available at [sandbox-sdk.app/docs](https://sandbox-sdk.app/docs).
+
+## License
+
+[MIT](./LICENSE) © OpenCore

package/dist/agentos-BOFA_q-a.mjs

@@ -0,0 +1,389 @@
+import { t as SandboxError } from "./errors-Ch9PHKTd.mjs";
+import { i as localCapabilities } from "./capabilities-CEowrzRM.mjs";
+import { n as portResult, o as withManagedSessions, r as toUint8Array } from "./provider-utils-DilOYLBO.mjs";
+import { randomUUID } from "node:crypto";
+
+//#region src/providers/agentos/index.ts
+const DEFAULT_PERMISSIONS = {
+	fs: "allow",
+	childProcess: "allow",
+	process: "allow",
+	env: "allow",
+	network: {
+		default: "deny",
+		rules: [{
+			mode: "allow",
+			operations: ["listen"],
+			patterns: ["**"]
+		}, {
+			mode: "allow",
+			operations: ["http"],
+			patterns: [
+				"tcp://127.0.0.1:*",
+				"tcp://[::1]:*",
+				"tcp://localhost:*"
+			]
+		}]
+	},
+	binding: "deny"
+};
+const DEFAULT_LIMITS = {
+	resources: {
+		cpuCount: 1,
+		maxProcesses: 64,
+		maxOpenFds: 256,
+		maxPipes: 128,
+		maxPtys: 16,
+		maxSockets: 128,
+		maxConnections: 64,
+		maxFilesystemBytes: 512 * 1024 * 1024,
+		maxInodeCount: 1e5,
+		maxWasmMemoryBytes: 256 * 1024 * 1024
+	},
+	http: { maxFetchResponseBytes: 16 * 1024 * 1024 },
+	jsRuntime: {
+		v8HeapLimitMb: 256,
+		wallClockLimitMs: 12e4,
+		capturedOutputLimitBytes: 8 * 1024 * 1024,
+		stdinBufferLimitBytes: 1024 * 1024
+	}
+};
+/**
+* Internal constructor for the AgentOS VM that powers the Local provider.
+*
+* Outbound networking is denied by default. Pass an explicit agentOS permission policy when the
+* guest needs network or host bindings.
+*/
+function createAgentOsProvider(options = {}) {
+	return withManagedSessions({
+		id: "local",
+		capabilities: localCapabilities,
+		async create(createOptions) {
+			const id = randomUUID();
+			const snapshots = /* @__PURE__ */ new Map();
+			const baseOptions = options.agentOs ?? {};
+			let vm = null;
+			let suspendedRoot;
+			let stopped = false;
+			const createVm = async (root) => {
+				let AgentOs;
+				try {
+					({AgentOs} = await import("@rivet-dev/agentos-core"));
+				} catch (error) {
+					throw new SandboxError({
+						code: "unavailable",
+						provider: "local",
+						operation: "sandbox.create",
+						message: "The Local provider could not load its @rivet-dev/agentos-core runtime dependency.",
+						cause: error
+					});
+				}
+				const next = await AgentOs.create({
+					...baseOptions,
+					permissions: baseOptions.permissions ?? DEFAULT_PERMISSIONS,
+					limits: baseOptions.limits ?? DEFAULT_LIMITS,
+					...root ? { rootFilesystem: {
+						disableDefaultBaseLayer: true,
+						lowers: [root]
+					} } : {}
+				});
+				await next.mkdir(createOptions.cwd, { recursive: true });
+				return next;
+			};
+			const currentVm = () => {
+				if (stopped) throw new SandboxError({
+					code: "terminated",
+					provider: "local",
+					operation: "sandbox",
+					message: "Sandbox has stopped"
+				});
+				if (!vm) throw new SandboxError({
+					code: "terminated",
+					provider: "local",
+					operation: "sandbox",
+					message: "Sandbox is suspended; call sandbox.raw.resume() before using it"
+				});
+				return vm;
+			};
+			const suspend = async () => {
+				if (stopped || !vm) return;
+				suspendedRoot = await vm.snapshotRootFilesystem();
+				await vm.dispose();
+				vm = null;
+			};
+			const resume = async () => {
+				if (stopped) throw new SandboxError({
+					code: "terminated",
+					provider: "local",
+					operation: "sandbox.resume",
+					message: "A stopped sandbox cannot be resumed"
+				});
+				if (vm) return;
+				vm = await createVm(suspendedRoot);
+				suspendedRoot = void 0;
+			};
+			vm = await createVm();
+			return {
+				id,
+				raw: {
+					get vm() {
+						return currentVm();
+					},
+					suspend,
+					resume
+				},
+				capabilities: localCapabilities,
+				files: {
+					write: async (path, value) => currentVm().writeFile(path, await toUint8Array(value)),
+					read: (path) => currentVm().readFile(path),
+					async list(path) {
+						return (await currentVm().readdirRecursive(path, { maxDepth: 0 })).map((entry) => ({
+							name: entry.path.slice(entry.path.lastIndexOf("/") + 1),
+							path: entry.path,
+							type: entry.type,
+							size: entry.type === "file" ? entry.size : void 0
+						}));
+					},
+					mkdir: (path) => currentVm().mkdir(path, { recursive: true }),
+					async remove(path) {
+						if (path === "/") throw new SandboxError({
+							code: "invalid_input",
+							provider: "local",
+							operation: "files.remove",
+							message: "Cannot remove the sandbox root"
+						});
+						await currentVm().delete(path, { recursive: true });
+					},
+					exists: (path) => currentVm().exists(path)
+				},
+				run: (command, runOptions) => runCommand(currentVm(), command, withEnv(createOptions, runOptions)),
+				async start(command, runOptions) {
+					return startProcess(currentVm(), command, withEnv(createOptions, runOptions));
+				},
+				async expose(port) {
+					validatePort(port);
+					const url = `http://agentos-${id}.internal:${port}`;
+					return portResult(port, url, false, false, (path = "/", init) => {
+						const request = new Request(new URL(path, url), init);
+						return currentVm().fetch(port, request);
+					});
+				},
+				snapshots: {
+					async create(snapshotOptions) {
+						const snapshot = {
+							id: randomUUID(),
+							name: snapshotOptions?.name,
+							mode: "filesystem",
+							createdAt: /* @__PURE__ */ new Date()
+						};
+						snapshots.set(snapshot.id, {
+							metadata: snapshot,
+							root: await currentVm().snapshotRootFilesystem()
+						});
+						return snapshot;
+					},
+					async delete(snapshot) {
+						const id$1 = typeof snapshot === "string" ? snapshot : snapshot.id;
+						if (!snapshots.delete(id$1)) throw snapshotNotFound(id$1, "snapshot.delete");
+					},
+					async restore(snapshot) {
+						const id$1 = typeof snapshot === "string" ? snapshot : snapshot.id;
+						const stored = snapshots.get(id$1);
+						if (!stored) throw snapshotNotFound(id$1, "snapshot.restore");
+						const previous = currentVm();
+						vm = null;
+						await previous.dispose();
+						try {
+							vm = await createVm(stored.root);
+						} catch (error) {
+							stopped = true;
+							throw error;
+						}
+					}
+				},
+				async stop() {
+					if (stopped) return;
+					stopped = true;
+					suspendedRoot = void 0;
+					snapshots.clear();
+					const active = vm;
+					vm = null;
+					await active?.dispose();
+				}
+			};
+		}
+	}, [], {
+		stop: (sandbox) => sandbox.raw.suspend(),
+		resume: (sandbox) => sandbox.raw.resume()
+	});
+}
+/**
+* @deprecated AgentOS now powers `local()` under the hood. Import `local` from
+* `@opencoredev/sandbox-sdk/local` instead.
+*/
+function agentos(options = {}) {
+	return createAgentOsProvider(options);
+}
+function withEnv(createOptions, runOptions) {
+	return {
+		...runOptions,
+		env: {
+			...createOptions.env,
+			...runOptions.env
+		}
+	};
+}
+function commandParts(command) {
+	return typeof command === "string" ? ["sh", ["-lc", command]] : [command.command, [...command.args ?? []]];
+}
+function startProcess(vm, command, options) {
+	if (options.signal?.aborted) throw interrupted("process.start");
+	const [executable, args] = commandParts(command);
+	const history = [];
+	const waiting = /* @__PURE__ */ new Set();
+	let state = "running";
+	let exitCode;
+	const push = (stream, data) => {
+		const output = stream === "stderr" ? withoutInternalAgentOsWarnings(data) : data;
+		if (output.byteLength === 0) return;
+		history.push({
+			stream,
+			data: new Uint8Array(output),
+			timestamp: /* @__PURE__ */ new Date()
+		});
+		for (const wake of waiting) wake();
+		waiting.clear();
+	};
+	const process = vm.spawn(executable, args, {
+		cwd: options.cwd,
+		env: options.env ? { ...options.env } : void 0,
+		streamStdin: true,
+		onStdout: (data) => push("stdout", data),
+		onStderr: (data) => push("stderr", data)
+	});
+	const completed = vm.waitProcess(process.pid).then((code) => {
+		exitCode = code;
+		state = code === 137 || code === 143 ? "killed" : "exited";
+		for (const wake of waiting) wake();
+		waiting.clear();
+		return { exitCode: code };
+	});
+	const abort = () => vm.stopProcess(process.pid);
+	options.signal?.addEventListener("abort", abort, { once: true });
+	completed.finally(() => options.signal?.removeEventListener("abort", abort));
+	return {
+		id: String(process.pid),
+		async status() {
+			return state;
+		},
+		async *output() {
+			let index = 0;
+			while (state === "running" || index < history.length) {
+				while (index < history.length) yield history[index++];
+				if (state !== "running") break;
+				await new Promise((resolve) => waiting.add(resolve));
+			}
+		},
+		write: (value) => vm.writeProcessStdin(process.pid, value),
+		wait: () => exitCode === void 0 ? completed : Promise.resolve({ exitCode }),
+		async kill(signal = "SIGTERM") {
+			if (state !== "running") return;
+			if (signal === "SIGKILL" || signal === "KILL" || signal === "9") vm.killProcess(process.pid);
+			else vm.stopProcess(process.pid);
+		}
+	};
+}
+function withoutInternalAgentOsWarnings(data) {
+	const value = new TextDecoder().decode(data).replaceAll("\x1B[33m WARN\x1B[0m could not retrieve pid for child process\n", "");
+	return new TextEncoder().encode(value);
+}
+async function runCommand(vm, command, options) {
+	const started = performance.now();
+	const process = startProcess(vm, command, options);
+	const stdout = [];
+	const stderr = [];
+	const collect = (async () => {
+		for await (const event of process.output()) {
+			const bytes = typeof event.data === "string" ? new TextEncoder().encode(event.data) : event.data;
+			(event.stream === "stdout" ? stdout : stderr).push(bytes);
+		}
+	})();
+	let timeout;
+	let removeAbort = () => {};
+	const interruptions = [];
+	if (options.timeout && options.timeout > 0) interruptions.push(new Promise((_, reject) => {
+		timeout = setTimeout(() => {
+			process.kill("SIGKILL");
+			reject(new SandboxError({
+				code: "timeout",
+				provider: "local",
+				operation: "process.run",
+				message: `Command timed out after ${options.timeout}ms`
+			}));
+		}, options.timeout);
+	}));
+	if (options.signal) interruptions.push(new Promise((_, reject) => {
+		const abort = () => {
+			process.kill("SIGKILL");
+			reject(interrupted("process.run"));
+		};
+		options.signal.addEventListener("abort", abort, { once: true });
+		removeAbort = () => options.signal.removeEventListener("abort", abort);
+	}));
+	try {
+		const result = await Promise.race([process.wait(), ...interruptions]);
+		await collect;
+		return {
+			stdout: decodeChunks(stdout),
+			stderr: decodeChunks(stderr),
+			exitCode: result.exitCode,
+			success: result.exitCode === 0,
+			durationMs: Math.round(performance.now() - started)
+		};
+	} catch (error) {
+		await process.wait().catch(() => {});
+		await collect.catch(() => {});
+		throw error;
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		removeAbort();
+	}
+}
+function decodeChunks(chunks) {
+	const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+	const output = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		output.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return new TextDecoder().decode(output);
+}
+function validatePort(port) {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new SandboxError({
+		code: "invalid_input",
+		provider: "local",
+		operation: "ports.expose",
+		message: `Invalid port: ${port}`
+	});
+}
+function snapshotNotFound(id, operation) {
+	return new SandboxError({
+		code: "not_found",
+		provider: "local",
+		operation,
+		message: `Snapshot not found: ${id}`
+	});
+}
+function interrupted(operation) {
+	return new SandboxError({
+		code: "terminated",
+		provider: "local",
+		operation,
+		message: "Operation was aborted"
+	});
+}
+
+//#endregion
+export { agentos as t };
+//# sourceMappingURL=agentos-BOFA_q-a.mjs.map

package/dist/agentos-BOFA_q-a.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentos-BOFA_q-a.mjs","names":["DEFAULT_PERMISSIONS: Permissions","DEFAULT_LIMITS: NonNullable<AgentOsOptions[\"limits\"]>","vm: AgentOsVm | null","suspendedRoot: RootSnapshotExport | undefined","AgentOs: (typeof import(\"@rivet-dev/agentos-core\"))[\"AgentOs\"]","snapshot: SandboxSnapshot","id","history: ProcessOutputEvent[]","state: ProcessStatus","exitCode: number | undefined","stdout: Uint8Array[]","stderr: Uint8Array[]","timeout: ReturnType<typeof setTimeout> | undefined","interruptions: Promise<never>[]"],"sources":["../src/providers/agentos/index.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type {\n  AgentOs as AgentOsVm,\n  AgentOsOptions,\n  Permissions,\n  RootSnapshotExport,\n} from \"@rivet-dev/agentos-core\";\nimport { SandboxError } from \"../../core/errors\";\nimport type { SandboxProvider, SandboxRuntime } from \"../../core/provider\";\nimport type {\n  CommandInput,\n  CommandResult,\n  ProcessOutputEvent,\n  ProcessStatus,\n  RunOptions,\n  SandboxDirectoryEntry,\n  SandboxProcess,\n  SandboxSnapshot,\n} from \"../../core/types\";\nimport { withManagedSessions } from \"../../internal/managed-provider\";\nimport { portResult, toUint8Array } from \"../../internal/provider-utils\";\nimport { localCapabilities } from \"../capabilities\";\n\nconst DEFAULT_PERMISSIONS: Permissions = {\n  fs: \"allow\",\n  childProcess: \"allow\",\n  process: \"allow\",\n  env: \"allow\",\n  network: {\n    default: \"deny\",\n    rules: [\n      { mode: \"allow\", operations: [\"listen\"], patterns: [\"**\"] },\n      {\n        mode: \"allow\",\n        operations: [\"http\"],\n        patterns: [\"tcp://127.0.0.1:*\", \"tcp://[::1]:*\", \"tcp://localhost:*\"],\n      },\n    ],\n  },\n  binding: \"deny\",\n};\n\nconst DEFAULT_LIMITS: NonNullable<AgentOsOptions[\"limits\"]> = {\n  resources: {\n    cpuCount: 1,\n    maxProcesses: 64,\n    maxOpenFds: 256,\n    maxPipes: 128,\n    maxPtys: 16,\n    maxSockets: 128,\n    maxConnections: 64,\n    maxFilesystemBytes: 512 * 1024 * 1024,\n    maxInodeCount: 100_000,\n    maxWasmMemoryBytes: 256 * 1024 * 1024,\n  },\n  http: { maxFetchResponseBytes: 16 * 1024 * 1024 },\n  jsRuntime: {\n    v8HeapLimitMb: 256,\n    wallClockLimitMs: 120_000,\n    capturedOutputLimitBytes: 8 * 1024 * 1024,\n    stdinBufferLimitBytes: 1024 * 1024,\n  },\n};\n\nexport interface AgentOsProviderOptions {\n  /**\n   * Native agentOS VM options. The provider supplies production-oriented permissions and limits\n   * unless these fields are explicitly provided.\n   */\n  agentOs?: AgentOsOptions;\n}\n\nexport interface AgentOsSandbox {\n  /** The currently running native VM. Access throws while the sandbox is suspended or stopped. */\n  readonly vm: AgentOsVm;\n  suspend(): Promise<void>;\n  resume(): Promise<void>;\n}\n\ntype StoredSnapshot = {\n  metadata: SandboxSnapshot;\n  root: RootSnapshotExport;\n};\n\nexport { agentosCapabilities } from \"../capabilities\";\n\n/**\n * Internal constructor for the AgentOS VM that powers the Local provider.\n *\n * Outbound networking is denied by default. Pass an explicit agentOS permission policy when the\n * guest needs network or host bindings.\n */\nfunction createAgentOsProvider(\n  options: AgentOsProviderOptions = {},\n): SandboxProvider<AgentOsSandbox> {\n  const provider: SandboxProvider<AgentOsSandbox> = {\n    id: \"local\",\n    capabilities: localCapabilities,\n    async create(createOptions) {\n      const id = randomUUID();\n      const snapshots = new Map<string, StoredSnapshot>();\n      const baseOptions = options.agentOs ?? {};\n      let vm: AgentOsVm | null = null;\n      let suspendedRoot: RootSnapshotExport | undefined;\n      let stopped = false;\n\n      const createVm = async (root?: RootSnapshotExport): Promise<AgentOsVm> => {\n        let AgentOs: (typeof import(\"@rivet-dev/agentos-core\"))[\"AgentOs\"];\n        try {\n          ({ AgentOs } = await import(\"@rivet-dev/agentos-core\"));\n        } catch (error) {\n          throw new SandboxError({\n            code: \"unavailable\",\n            provider: \"local\",\n            operation: \"sandbox.create\",\n            message:\n              \"The Local provider could not load its @rivet-dev/agentos-core runtime dependency.\",\n            cause: error,\n          });\n        }\n        const next = await AgentOs.create({\n          ...baseOptions,\n          permissions: baseOptions.permissions ?? DEFAULT_PERMISSIONS,\n          limits: baseOptions.limits ?? DEFAULT_LIMITS,\n          ...(root\n            ? {\n                rootFilesystem: {\n                  disableDefaultBaseLayer: true,\n                  lowers: [root],\n                },\n              }\n            : {}),\n        });\n        await next.mkdir(createOptions.cwd, { recursive: true });\n        return next;\n      };\n\n      const currentVm = (): AgentOsVm => {\n        if (stopped)\n          throw new SandboxError({\n            code: \"terminated\",\n            provider: \"local\",\n            operation: \"sandbox\",\n            message: \"Sandbox has stopped\",\n          });\n        if (!vm)\n          throw new SandboxError({\n            code: \"terminated\",\n            provider: \"local\",\n            operation: \"sandbox\",\n            message: \"Sandbox is suspended; call sandbox.raw.resume() before using it\",\n          });\n        return vm;\n      };\n\n      const suspend = async () => {\n        if (stopped || !vm) return;\n        suspendedRoot = await vm.snapshotRootFilesystem();\n        await vm.dispose();\n        vm = null;\n      };\n\n      const resume = async () => {\n        if (stopped)\n          throw new SandboxError({\n            code: \"terminated\",\n            provider: \"local\",\n            operation: \"sandbox.resume\",\n            message: \"A stopped sandbox cannot be resumed\",\n          });\n        if (vm) return;\n        vm = await createVm(suspendedRoot);\n        suspendedRoot = undefined;\n      };\n\n      vm = await createVm();\n      const raw: AgentOsSandbox = {\n        get vm() {\n          return currentVm();\n        },\n        suspend,\n        resume,\n      };\n\n      const runtime: SandboxRuntime<AgentOsSandbox> = {\n        id,\n        raw,\n        capabilities: localCapabilities,\n        files: {\n          write: async (path, value) => currentVm().writeFile(path, await toUint8Array(value)),\n          read: (path) => currentVm().readFile(path),\n          async list(path) {\n            const entries = await currentVm().readdirRecursive(path, { maxDepth: 0 });\n            return entries.map(\n              (entry): SandboxDirectoryEntry => ({\n                name: entry.path.slice(entry.path.lastIndexOf(\"/\") + 1),\n                path: entry.path,\n                type: entry.type,\n                size: entry.type === \"file\" ? entry.size : undefined,\n              }),\n            );\n          },\n          mkdir: (path) => currentVm().mkdir(path, { recursive: true }),\n          async remove(path) {\n            if (path === \"/\")\n              throw new SandboxError({\n                code: \"invalid_input\",\n                provider: \"local\",\n                operation: \"files.remove\",\n                message: \"Cannot remove the sandbox root\",\n              });\n            await currentVm().delete(path, { recursive: true });\n          },\n          exists: (path) => currentVm().exists(path),\n        },\n        run: (command, runOptions) =>\n          runCommand(currentVm(), command, withEnv(createOptions, runOptions)),\n        async start(command, runOptions) {\n          return startProcess(currentVm(), command, withEnv(createOptions, runOptions));\n        },\n        async expose(port) {\n          validatePort(port);\n          const url = `http://agentos-${id}.internal:${port}`;\n          return portResult(port, url, false, false, (path = \"/\", init) => {\n            const request = new Request(new URL(path, url), init);\n            return currentVm().fetch(port, request);\n          });\n        },\n        snapshots: {\n          async create(snapshotOptions) {\n            const snapshot: SandboxSnapshot = {\n              id: randomUUID(),\n              name: snapshotOptions?.name,\n              mode: \"filesystem\",\n              createdAt: new Date(),\n            };\n            snapshots.set(snapshot.id, {\n              metadata: snapshot,\n              root: await currentVm().snapshotRootFilesystem(),\n            });\n            return snapshot;\n          },\n          async delete(snapshot) {\n            const id = typeof snapshot === \"string\" ? snapshot : snapshot.id;\n            if (!snapshots.delete(id)) throw snapshotNotFound(id, \"snapshot.delete\");\n          },\n          async restore(snapshot) {\n            const id = typeof snapshot === \"string\" ? snapshot : snapshot.id;\n            const stored = snapshots.get(id);\n            if (!stored) throw snapshotNotFound(id, \"snapshot.restore\");\n            const previous = currentVm();\n            vm = null;\n            await previous.dispose();\n            try {\n              vm = await createVm(stored.root);\n            } catch (error) {\n              stopped = true;\n              throw error;\n            }\n          },\n        },\n        async stop() {\n          if (stopped) return;\n          stopped = true;\n          suspendedRoot = undefined;\n          snapshots.clear();\n          const active = vm;\n          vm = null;\n          await active?.dispose();\n        },\n      };\n      return runtime;\n    },\n  };\n\n  return withManagedSessions(provider, [], {\n    stop: (sandbox) => sandbox.raw.suspend(),\n    resume: (sandbox) => sandbox.raw.resume(),\n  });\n}\n\n/**\n * @deprecated AgentOS now powers `local()` under the hood. Import `local` from\n * `@opencoredev/sandbox-sdk/local` instead.\n */\nexport function agentos(options: AgentOsProviderOptions = {}): SandboxProvider<AgentOsSandbox> {\n  return createAgentOsProvider(options);\n}\n\nfunction withEnv(\n  createOptions: { env: Readonly<Record<string, string>> },\n  runOptions: RunOptions,\n): RunOptions {\n  return { ...runOptions, env: { ...createOptions.env, ...runOptions.env } };\n}\n\nfunction commandParts(command: CommandInput): [string, string[]] {\n  return typeof command === \"string\"\n    ? [\"sh\", [\"-lc\", command]]\n    : [command.command, [...(command.args ?? [])]];\n}\n\nfunction startProcess(vm: AgentOsVm, command: CommandInput, options: RunOptions): SandboxProcess {\n  if (options.signal?.aborted) throw interrupted(\"process.start\");\n  const [executable, args] = commandParts(command);\n  const history: ProcessOutputEvent[] = [];\n  const waiting = new Set<() => void>();\n  let state: ProcessStatus = \"running\";\n  let exitCode: number | undefined;\n  const push = (stream: \"stdout\" | \"stderr\", data: Uint8Array) => {\n    const output = stream === \"stderr\" ? withoutInternalAgentOsWarnings(data) : data;\n    if (output.byteLength === 0) return;\n    history.push({ stream, data: new Uint8Array(output), timestamp: new Date() });\n    for (const wake of waiting) wake();\n    waiting.clear();\n  };\n  const process = vm.spawn(executable, args, {\n    cwd: options.cwd,\n    env: options.env ? { ...options.env } : undefined,\n    streamStdin: true,\n    onStdout: (data) => push(\"stdout\", data),\n    onStderr: (data) => push(\"stderr\", data),\n  });\n  const completed = vm.waitProcess(process.pid).then((code) => {\n    exitCode = code;\n    state = code === 137 || code === 143 ? \"killed\" : \"exited\";\n    for (const wake of waiting) wake();\n    waiting.clear();\n    return { exitCode: code };\n  });\n  const abort = () => vm.stopProcess(process.pid);\n  options.signal?.addEventListener(\"abort\", abort, { once: true });\n  void completed.finally(() => options.signal?.removeEventListener(\"abort\", abort));\n\n  return {\n    id: String(process.pid),\n    async status() {\n      return state;\n    },\n    async *output() {\n      let index = 0;\n      while (state === \"running\" || index < history.length) {\n        while (index < history.length) yield history[index++]!;\n        if (state !== \"running\") break;\n        await new Promise<void>((resolve) => waiting.add(resolve));\n      }\n    },\n    write: (value) => vm.writeProcessStdin(process.pid, value),\n    wait: () => (exitCode === undefined ? completed : Promise.resolve({ exitCode })),\n    async kill(signal = \"SIGTERM\") {\n      if (state !== \"running\") return;\n      if (signal === \"SIGKILL\" || signal === \"KILL\" || signal === \"9\") vm.killProcess(process.pid);\n      else vm.stopProcess(process.pid);\n    },\n  };\n}\n\nfunction withoutInternalAgentOsWarnings(data: Uint8Array): Uint8Array {\n  const value = new TextDecoder()\n    .decode(data)\n    .replaceAll(\"\\u001b[33m WARN\\u001b[0m could not retrieve pid for child process\\n\", \"\");\n  return new TextEncoder().encode(value);\n}\n\nasync function runCommand(\n  vm: AgentOsVm,\n  command: CommandInput,\n  options: RunOptions,\n): Promise<CommandResult> {\n  const started = performance.now();\n  const process = startProcess(vm, command, options);\n  const stdout: Uint8Array[] = [];\n  const stderr: Uint8Array[] = [];\n  const collect = (async () => {\n    for await (const event of process.output()) {\n      const bytes =\n        typeof event.data === \"string\" ? new TextEncoder().encode(event.data) : event.data;\n      (event.stream === \"stdout\" ? stdout : stderr).push(bytes);\n    }\n  })();\n  let timeout: ReturnType<typeof setTimeout> | undefined;\n  let removeAbort = () => {};\n  const interruptions: Promise<never>[] = [];\n\n  if (options.timeout && options.timeout > 0) {\n    interruptions.push(\n      new Promise<never>((_, reject) => {\n        timeout = setTimeout(() => {\n          void process.kill(\"SIGKILL\");\n          reject(\n            new SandboxError({\n              code: \"timeout\",\n              provider: \"local\",\n              operation: \"process.run\",\n              message: `Command timed out after ${options.timeout}ms`,\n            }),\n          );\n        }, options.timeout);\n      }),\n    );\n  }\n  if (options.signal) {\n    interruptions.push(\n      new Promise<never>((_, reject) => {\n        const abort = () => {\n          void process.kill(\"SIGKILL\");\n          reject(interrupted(\"process.run\"));\n        };\n        options.signal!.addEventListener(\"abort\", abort, { once: true });\n        removeAbort = () => options.signal!.removeEventListener(\"abort\", abort);\n      }),\n    );\n  }\n\n  try {\n    const result = await Promise.race([process.wait(), ...interruptions]);\n    await collect;\n    return {\n      stdout: decodeChunks(stdout),\n      stderr: decodeChunks(stderr),\n      exitCode: result.exitCode,\n      success: result.exitCode === 0,\n      durationMs: Math.round(performance.now() - started),\n    };\n  } catch (error) {\n    await process.wait().catch(() => {});\n    await collect.catch(() => {});\n    throw error;\n  } finally {\n    if (timeout) clearTimeout(timeout);\n    removeAbort();\n  }\n}\n\nfunction decodeChunks(chunks: Uint8Array[]): string {\n  const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);\n  const output = new Uint8Array(length);\n  let offset = 0;\n  for (const chunk of chunks) {\n    output.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return new TextDecoder().decode(output);\n}\n\nfunction validatePort(port: number): void {\n  if (!Number.isInteger(port) || port < 1 || port > 65_535)\n    throw new SandboxError({\n      code: \"invalid_input\",\n      provider: \"local\",\n      operation: \"ports.expose\",\n      message: `Invalid port: ${port}`,\n    });\n}\n\nfunction snapshotNotFound(id: string, operation: string): SandboxError {\n  return new SandboxError({\n    code: \"not_found\",\n    provider: \"local\",\n    operation,\n    message: `Snapshot not found: ${id}`,\n  });\n}\n\nfunction interrupted(operation: string): SandboxError {\n  return new SandboxError({\n    code: \"terminated\",\n    provider: \"local\",\n    operation,\n    message: \"Operation was aborted\",\n  });\n}\n"],"mappings":"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"}

package/dist/ai/harness.d.mts

@@ -0,0 +1,16 @@
+import "../types-BTagTtsp.mjs";
+import { o as SandboxProvider } from "../provider-_caCV8kk.mjs";
+import { HarnessV1NetworkPolicy, HarnessV1NetworkSandboxSession, HarnessV1SandboxProvider, HarnessV1SandboxProvider as HarnessV1SandboxProvider$1 } from "@ai-sdk/harness";
+
+//#region src/ai/harness.d.ts
+interface CreateSandboxHarnessProviderOptions {
+  provider: SandboxProvider<unknown>;
+  ports?: ReadonlyArray<number>;
+  cwd?: string;
+  env?: Readonly<Record<string, string>>;
+}
+/** Create an AI SDK Harness sandbox provider backed by any managed sandbox-sdk provider. */
+declare function createSandboxHarnessProvider(options: CreateSandboxHarnessProviderOptions): HarnessV1SandboxProvider$1;
+//#endregion
+export { CreateSandboxHarnessProviderOptions, type HarnessV1NetworkPolicy, type HarnessV1NetworkSandboxSession, type HarnessV1SandboxProvider, createSandboxHarnessProvider };
+//# sourceMappingURL=harness.d.mts.map

package/dist/ai/harness.mjs

@@ -0,0 +1,69 @@
+import { t as SandboxError } from "../errors-Ch9PHKTd.mjs";
+import { r as toAISandboxSession } from "../ai-DhfwIZdL.mjs";
+
+//#region src/ai/harness.ts
+/** Create an AI SDK Harness sandbox provider backed by any managed sandbox-sdk provider. */
+function createSandboxHarnessProvider(options) {
+	const managed = requireManaged(options.provider);
+	return {
+		specificationVersion: "harness-sandbox-v1",
+		providerId: `sandbox-sdk:${options.provider.id}`,
+		async createSession(createOptions = {}) {
+			const sessionId = createOptions.sessionId ?? crypto.randomUUID();
+			return toHarnessSession(await managed.create({
+				sessionId,
+				identity: createOptions.identity,
+				cwd: options.cwd,
+				env: options.env,
+				ports: options.ports,
+				signal: createOptions.abortSignal,
+				onFirstCreate: createOptions.onFirstCreate ? (sandbox) => createOptions.onFirstCreate(toAISandboxSession(sandbox), { abortSignal: createOptions.abortSignal }) : void 0
+			}));
+		},
+		async resumeSession(resumeOptions) {
+			return toHarnessSession(await managed.resume({
+				sessionId: resumeOptions.sessionId,
+				signal: resumeOptions.abortSignal
+			}));
+		}
+	};
+}
+function toHarnessSession(session) {
+	const restricted = toAISandboxSession(session.sandbox);
+	return {
+		...restricted,
+		id: session.id,
+		defaultWorkingDirectory: session.defaultWorkingDirectory,
+		get ports() {
+			return session.ports;
+		},
+		getPortUrl: (options) => session.getPortUrl(options),
+		stop: () => session.stop(),
+		destroy: () => session.destroy(),
+		...session.setPorts ? { setPorts: (ports, options) => session.setPorts(ports, { signal: options?.abortSignal }) } : {},
+		...session.setNetworkPolicy ? { setNetworkPolicy: (policy) => session.setNetworkPolicy(toCoreNetworkPolicy(policy)) } : {},
+		restricted: () => restricted
+	};
+}
+function toCoreNetworkPolicy(policy) {
+	if (policy.mode !== "custom") return policy;
+	return {
+		mode: "custom",
+		allowedHosts: policy.allowedHosts,
+		allowedCIDRs: policy.allowedCIDRs,
+		deniedCIDRs: policy.deniedCIDRs
+	};
+}
+function requireManaged(provider) {
+	if (!provider.managed) throw new SandboxError({
+		code: "unsupported",
+		provider: provider.id,
+		operation: "harness.createProvider",
+		message: `Provider ${provider.id} does not implement managed sandbox sessions`
+	});
+	return provider.managed;
+}
+
+//#endregion
+export { createSandboxHarnessProvider };
+//# sourceMappingURL=harness.mjs.map

package/dist/ai/harness.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.mjs","names":[],"sources":["../../src/ai/harness.ts"],"sourcesContent":["import type {\n  HarnessV1NetworkPolicy,\n  HarnessV1NetworkSandboxSession,\n  HarnessV1SandboxProvider,\n} from \"@ai-sdk/harness\";\nimport type { Experimental_SandboxSession } from \"ai\";\nimport { SandboxError } from \"../core/errors\";\nimport type {\n  ManagedSandboxSession,\n  SandboxNetworkPolicy,\n  SandboxProvider,\n} from \"../core/provider\";\nimport { toAISandboxSession } from \"./index\";\n\nexport interface CreateSandboxHarnessProviderOptions {\n  provider: SandboxProvider<unknown>;\n  ports?: ReadonlyArray<number>;\n  cwd?: string;\n  env?: Readonly<Record<string, string>>;\n}\n\n/** Create an AI SDK Harness sandbox provider backed by any managed sandbox-sdk provider. */\nexport function createSandboxHarnessProvider(\n  options: CreateSandboxHarnessProviderOptions,\n): HarnessV1SandboxProvider {\n  const managed = requireManaged(options.provider);\n  return {\n    specificationVersion: \"harness-sandbox-v1\",\n    providerId: `sandbox-sdk:${options.provider.id}`,\n    async createSession(createOptions = {}) {\n      const sessionId = createOptions.sessionId ?? crypto.randomUUID();\n      const session = await managed.create({\n        sessionId,\n        identity: createOptions.identity,\n        cwd: options.cwd,\n        env: options.env,\n        ports: options.ports,\n        signal: createOptions.abortSignal,\n        onFirstCreate: createOptions.onFirstCreate\n          ? (sandbox) =>\n              createOptions.onFirstCreate!(toAISandboxSession(sandbox), {\n                abortSignal: createOptions.abortSignal,\n              })\n          : undefined,\n      });\n      return toHarnessSession(session);\n    },\n    async resumeSession(resumeOptions) {\n      return toHarnessSession(\n        await managed.resume({\n          sessionId: resumeOptions.sessionId,\n          signal: resumeOptions.abortSignal,\n        }),\n      );\n    },\n  };\n}\n\nfunction toHarnessSession(session: ManagedSandboxSession): HarnessV1NetworkSandboxSession {\n  const restricted = toAISandboxSession(session.sandbox);\n  return {\n    ...restricted,\n    id: session.id,\n    defaultWorkingDirectory: session.defaultWorkingDirectory,\n    get ports() {\n      return session.ports;\n    },\n    getPortUrl: (options) => session.getPortUrl(options),\n    stop: () => session.stop(),\n    destroy: () => session.destroy(),\n    ...(session.setPorts\n      ? {\n          setPorts: (ports: ReadonlyArray<number>, options?: { abortSignal?: AbortSignal }) =>\n            session.setPorts!(ports, { signal: options?.abortSignal }),\n        }\n      : {}),\n    ...(session.setNetworkPolicy\n      ? {\n          setNetworkPolicy: (policy: HarnessV1NetworkPolicy) =>\n            session.setNetworkPolicy!(toCoreNetworkPolicy(policy)),\n        }\n      : {}),\n    restricted: (): Experimental_SandboxSession => restricted,\n  };\n}\n\nfunction toCoreNetworkPolicy(policy: HarnessV1NetworkPolicy): SandboxNetworkPolicy {\n  if (policy.mode !== \"custom\") return policy;\n  return {\n    mode: \"custom\",\n    allowedHosts: policy.allowedHosts,\n    allowedCIDRs: policy.allowedCIDRs,\n    deniedCIDRs: policy.deniedCIDRs,\n  };\n}\n\nfunction requireManaged(provider: SandboxProvider<unknown>) {\n  if (!provider.managed) {\n    throw new SandboxError({\n      code: \"unsupported\",\n      provider: provider.id,\n      operation: \"harness.createProvider\",\n      message: `Provider ${provider.id} does not implement managed sandbox sessions`,\n    });\n  }\n  return provider.managed;\n}\n\nexport type {\n  HarnessV1NetworkPolicy,\n  HarnessV1NetworkSandboxSession,\n  HarnessV1SandboxProvider,\n} from \"@ai-sdk/harness\";\n"],"mappings":";;;;;AAsBA,SAAgB,6BACd,SAC0B;CAC1B,MAAM,UAAU,eAAe,QAAQ,SAAS;AAChD,QAAO;EACL,sBAAsB;EACtB,YAAY,eAAe,QAAQ,SAAS;EAC5C,MAAM,cAAc,gBAAgB,EAAE,EAAE;GACtC,MAAM,YAAY,cAAc,aAAa,OAAO,YAAY;AAehE,UAAO,iBAdS,MAAM,QAAQ,OAAO;IACnC;IACA,UAAU,cAAc;IACxB,KAAK,QAAQ;IACb,KAAK,QAAQ;IACb,OAAO,QAAQ;IACf,QAAQ,cAAc;IACtB,eAAe,cAAc,iBACxB,YACC,cAAc,cAAe,mBAAmB,QAAQ,EAAE,EACxD,aAAa,cAAc,aAC5B,CAAC,GACJ;IACL,CAAC,CAC8B;;EAElC,MAAM,cAAc,eAAe;AACjC,UAAO,iBACL,MAAM,QAAQ,OAAO;IACnB,WAAW,cAAc;IACzB,QAAQ,cAAc;IACvB,CAAC,CACH;;EAEJ;;AAGH,SAAS,iBAAiB,SAAgE;CACxF,MAAM,aAAa,mBAAmB,QAAQ,QAAQ;AACtD,QAAO;EACL,GAAG;EACH,IAAI,QAAQ;EACZ,yBAAyB,QAAQ;EACjC,IAAI,QAAQ;AACV,UAAO,QAAQ;;EAEjB,aAAa,YAAY,QAAQ,WAAW,QAAQ;EACpD,YAAY,QAAQ,MAAM;EAC1B,eAAe,QAAQ,SAAS;EAChC,GAAI,QAAQ,WACR,EACE,WAAW,OAA8B,YACvC,QAAQ,SAAU,OAAO,EAAE,QAAQ,SAAS,aAAa,CAAC,EAC7D,GACD,EAAE;EACN,GAAI,QAAQ,mBACR,EACE,mBAAmB,WACjB,QAAQ,iBAAkB,oBAAoB,OAAO,CAAC,EACzD,GACD,EAAE;EACN,kBAA+C;EAChD;;AAGH,SAAS,oBAAoB,QAAsD;AACjF,KAAI,OAAO,SAAS,SAAU,QAAO;AACrC,QAAO;EACL,MAAM;EACN,cAAc,OAAO;EACrB,cAAc,OAAO;EACrB,aAAa,OAAO;EACrB;;AAGH,SAAS,eAAe,UAAoC;AAC1D,KAAI,CAAC,SAAS,QACZ,OAAM,IAAI,aAAa;EACrB,MAAM;EACN,UAAU,SAAS;EACnB,WAAW;EACX,SAAS,YAAY,SAAS,GAAG;EAClC,CAAC;AAEJ,QAAO,SAAS"}

package/dist/ai/index.d.mts

@@ -0,0 +1,54 @@
+import { f as Sandbox } from "../types-BTagTtsp.mjs";
+import { Experimental_SandboxSession, Tool, ToolSet } from "ai";
+
+//#region src/ai/index.d.ts
+interface AISandboxSessionOptions {
+  description?: string;
+}
+type SandboxToolApproval = "mutations" | "always" | "never";
+type SandboxToolApprovalConfiguration = Readonly<{
+  bash: "user-approval" | "not-applicable";
+  read_file: "user-approval" | "not-applicable";
+  write_file: "user-approval" | "not-applicable";
+}>;
+/**
+ * Adapt a sandbox-sdk sandbox to AI SDK 7's experimental sandbox contract.
+ * The caller continues to own the original sandbox and must stop it.
+ */
+declare function toAISandboxSession(sandbox: Sandbox, options?: AISandboxSessionOptions): Experimental_SandboxSession;
+type BashInput = {
+  command: string;
+  workingDirectory?: string;
+  env?: Record<string, string>;
+};
+type ReadFileInput = {
+  path: string;
+  encoding?: string;
+  startLine?: number;
+  endLine?: number;
+};
+type WriteFileInput = {
+  path: string;
+  content: string;
+  encoding?: string;
+};
+type SandboxTools = ToolSet & {
+  bash: Tool<BashInput, {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+  }>;
+  read_file: Tool<ReadFileInput, {
+    content: string | null;
+  }>;
+  write_file: Tool<WriteFileInput, {
+    written: true;
+  }>;
+};
+/** Ready-made AI SDK tools that execute only through `experimental_sandbox`. */
+declare function createSandboxTools(): SandboxTools;
+/** Create the AI SDK 7 `toolApproval` policy for the ready-made sandbox tools. */
+declare function createSandboxToolApproval(approval?: SandboxToolApproval): SandboxToolApprovalConfiguration;
+//#endregion
+export { AISandboxSessionOptions, SandboxToolApproval, SandboxToolApprovalConfiguration, SandboxTools, createSandboxToolApproval, createSandboxTools, toAISandboxSession };
+//# sourceMappingURL=index.d.mts.map

package/dist/ai/index.mjs

@@ -0,0 +1,4 @@
+import "../errors-Ch9PHKTd.mjs";
+import { n as createSandboxTools, r as toAISandboxSession, t as createSandboxToolApproval } from "../ai-DhfwIZdL.mjs";
+
+export { createSandboxToolApproval, createSandboxTools, toAISandboxSession };