@opencoredev/sandbox-sdk 0.1.1 → 1.0.0-beta.0

package/dist/mastra/index.mjs

@@ -1,662 +0,0 @@
-import { n as isSandboxError, t as SandboxError } from "../errors-Ch9PHKTd.mjs";
-import { DirectoryNotEmptyError, DirectoryNotFoundError, FileExistsError, FileNotFoundError, IsDirectoryError, MastraFilesystem, MastraSandbox, NotDirectoryError, PermissionError, ProcessHandle, SandboxNotReadyError, SandboxProcessManager, StaleFileError, Workspace, WorkspaceReadOnlyError } from "@mastra/core/workspace";
-
-//#region src/mastra/index.ts
-/** Create a Mastra sandbox backed by any managed Sandbox SDK provider. */
-function createMastraSandbox(options) {
-	return new SandboxSDKMastraSandbox(options);
-}
-/**
-* Create a Mastra workspace whose filesystem and commands share one Sandbox SDK
-* session. The workspace owns and destroys the session.
-*/
-function createMastraWorkspace(options) {
-	const sandbox = createMastraSandbox(options);
-	const filesystem = new SandboxSDKMastraFilesystem({
-		...options.filesystem,
-		sandbox
-	});
-	return new Workspace({
-		...options.workspace,
-		filesystem,
-		sandbox
-	});
-}
-/** Mastra WorkspaceSandbox implementation for Sandbox SDK providers. */
-var SandboxSDKMastraSandbox = class extends MastraSandbox {
-	id;
-	name;
-	provider;
-	cwd;
-	processes;
-	status = "pending";
-	managed;
-	identity;
-	env;
-	ports;
-	instructions;
-	onFirstCreate;
-	createdAt = /* @__PURE__ */ new Date();
-	session;
-	constructor(options) {
-		const processes = new SandboxSDKProcessManager({ env: options.env });
-		super({
-			...options,
-			name: "Sandbox SDK",
-			processes
-		});
-		this.managed = requireManaged(options.provider);
-		this.id = options.id ?? `mastra-${options.provider.id}-${crypto.randomUUID()}`;
-		this.name = `Sandbox SDK (${options.provider.id})`;
-		this.provider = options.provider.id;
-		this.cwd = normalizeCwd(options.cwd ?? "/workspace");
-		this.env = options.env ?? {};
-		this.ports = options.ports ?? [];
-		this.identity = options.identity;
-		this.instructions = options.instructions;
-		this.onFirstCreate = options.onFirstCreate;
-		this.processes = processes;
-	}
-	/** The live normalized Sandbox SDK session. */
-	get sandboxSdk() {
-		if (!this.session) throw new SandboxNotReadyError(this.id);
-		return this.session.sandbox;
-	}
-	async start() {
-		if (this.session) {
-			await this.session.resume();
-			return;
-		}
-		this.session = await this.managed.create({
-			sessionId: this.id,
-			identity: this.identity,
-			cwd: this.cwd,
-			env: this.env,
-			ports: this.ports,
-			onFirstCreate: this.onFirstCreate
-		});
-	}
-	async stop() {
-		if (!this.session) return;
-		await this.killTrackedProcesses();
-		await this.session.stop();
-	}
-	async destroy() {
-		if (!this.session) return;
-		await this.killTrackedProcesses();
-		const session = this.session;
-		this.session = void 0;
-		await session.destroy();
-	}
-	async getPortUrl(port, protocol) {
-		await this.ensureRunning();
-		return this.session.getPortUrl({
-			port,
-			protocol
-		});
-	}
-	getInfo() {
-		return {
-			id: this.id,
-			name: this.name,
-			provider: this.provider,
-			status: this.status,
-			createdAt: this.createdAt,
-			metadata: {
-				sandboxId: this.session?.sandbox.id,
-				sandboxProvider: this.provider,
-				cwd: this.cwd,
-				capabilities: this.session?.sandbox.capabilities
-			}
-		};
-	}
-	getInstructions(options) {
-		const defaultInstructions = `Commands run in an isolated ${this.provider} sandbox. The default working directory is ${this.cwd}.`;
-		if (this.instructions === void 0) return defaultInstructions;
-		if (typeof this.instructions === "string") return this.instructions;
-		return this.instructions({
-			defaultInstructions,
-			requestContext: options?.requestContext
-		});
-	}
-	/** @deprecated Use `status === "running"` instead. */
-	isReady() {
-		return this.status === "running" && this.session !== void 0;
-	}
-	async killTrackedProcesses() {
-		const processes = await this.processes.list().catch(() => []);
-		await Promise.all(processes.filter((process) => process.running).map((process) => this.processes.kill(process.pid).catch(() => false)));
-	}
-};
-/** Mastra background-process bridge for normalized Sandbox SDK processes. */
-var SandboxSDKProcessManager = class extends SandboxProcessManager {
-	async spawn(command, options = {}) {
-		const env = Object.fromEntries(Object.entries({
-			...this.env,
-			...options.env
-		}).filter((entry) => entry[1] !== void 0));
-		const handle = new SandboxSDKProcessHandle(await this.sandbox.sandboxSdk.processes.start(parseSimpleCommand(command) ?? command, {
-			cwd: options.cwd,
-			env,
-			timeout: options.timeout,
-			signal: options.abortSignal
-		}), options);
-		this._tracked.set(handle.pid, handle);
-		return handle;
-	}
-	async list() {
-		return Promise.all([...this._tracked.values()].map(async (handle) => {
-			const adapter = handle;
-			return {
-				pid: handle.pid,
-				command: handle.command,
-				running: await adapter.isRunning(),
-				...handle.exitCode === void 0 ? {} : { exitCode: handle.exitCode }
-			};
-		}));
-	}
-};
-var SandboxSDKProcessHandle = class extends ProcessHandle {
-	pid;
-	process;
-	startedAt = performance.now();
-	completed;
-	currentExitCode;
-	killed = false;
-	timedOut = false;
-	timeoutId;
-	constructor(process, options) {
-		super(options);
-		this.process = process;
-		this.pid = process.id;
-		if (options.timeout !== void 0 && options.timeout > 0) this.timeoutId = setTimeout(() => {
-			this.timedOut = true;
-			this.kill();
-		}, options.timeout);
-		this.completed = this.collect();
-	}
-	get exitCode() {
-		return this.currentExitCode;
-	}
-	async wait() {
-		return this.completed;
-	}
-	async kill() {
-		if (this.currentExitCode !== void 0) return false;
-		this.killed = true;
-		await this.process.kill();
-		return true;
-	}
-	async sendStdin(data) {
-		if (this.currentExitCode !== void 0) throw new Error(`Process ${this.pid} has already exited with code ${this.currentExitCode}`);
-		await this.process.write(data);
-	}
-	async isRunning() {
-		if (this.currentExitCode !== void 0) return false;
-		const status = await this.process.status();
-		return status === "starting" || status === "running";
-	}
-	async collect() {
-		const output = this.pumpOutput();
-		try {
-			const result = await this.process.wait();
-			this.currentExitCode = this.timedOut ? 124 : result.exitCode;
-			await output;
-		} catch (error) {
-			await output.catch(() => void 0);
-			if (isSandboxError(error) && error.code === "timeout") this.timedOut = true;
-			this.currentExitCode = this.timedOut ? 124 : 1;
-			this.emitStderr(error instanceof Error ? error.message : String(error));
-		} finally {
-			if (this.timeoutId) clearTimeout(this.timeoutId);
-		}
-		return {
-			success: this.currentExitCode === 0,
-			exitCode: this.currentExitCode,
-			stdout: this.stdout,
-			stderr: this.stderr,
-			executionTimeMs: Math.round(performance.now() - this.startedAt),
-			...this.killed ? { killed: true } : {},
-			...this.timedOut ? { timedOut: true } : {}
-		};
-	}
-	async pumpOutput() {
-		const decoders = {
-			stdout: new TextDecoder(),
-			stderr: new TextDecoder()
-		};
-		try {
-			for await (const event of this.process.output()) {
-				const data = typeof event.data === "string" ? event.data : decoders[event.stream].decode(event.data, { stream: true });
-				if (data) if (event.stream === "stdout") this.emitStdout(data);
-				else this.emitStderr(data);
-			}
-		} finally {
-			const stdout = decoders.stdout.decode();
-			const stderr = decoders.stderr.decode();
-			if (stdout) this.emitStdout(stdout);
-			if (stderr) this.emitStderr(stderr);
-		}
-	}
-};
-/** Mastra WorkspaceFilesystem implementation sharing a Mastra sandbox session. */
-var SandboxSDKMastraFilesystem = class extends MastraFilesystem {
-	id;
-	name = "Sandbox SDK Filesystem";
-	provider = "sandbox-sdk";
-	readOnly;
-	basePath;
-	status = "pending";
-	sandbox;
-	instructions;
-	constructor(options) {
-		super({
-			...options,
-			name: "Sandbox SDK Filesystem"
-		});
-		this.sandbox = options.sandbox;
-		this.id = `${options.sandbox.id}-filesystem`;
-		this.basePath = options.sandbox.cwd;
-		this.readOnly = options.readOnly ?? false;
-		this.instructions = options.instructions;
-	}
-	async init() {}
-	async destroy() {}
-	getInfo() {
-		return {
-			id: this.id,
-			name: this.name,
-			provider: this.provider,
-			status: this.status,
-			readOnly: this.readOnly,
-			metadata: {
-				sandboxId: this.sandbox.id,
-				sandboxProvider: this.sandbox.provider,
-				basePath: this.basePath
-			}
-		};
-	}
-	getInstructions(options) {
-		const defaultInstructions = `Files are stored in the same ${this.sandbox.provider} sandbox used for commands. Filesystem path / maps to ${this.basePath} inside the sandbox.`;
-		if (this.instructions === void 0) return defaultInstructions;
-		if (typeof this.instructions === "string") return this.instructions;
-		return this.instructions({
-			defaultInstructions,
-			requestContext: options?.requestContext
-		});
-	}
-	async realpath(path) {
-		await this.ready();
-		const virtual = toVirtualPath(this.basePath, path);
-		const result = await this.sandbox.sandboxSdk.run({
-			command: "realpath",
-			args: ["-m", toSandboxPath(this.basePath, virtual)]
-		});
-		if (!result.success) return virtual;
-		const resolved = result.stdout.trim();
-		if (!isWithin(this.basePath, resolved)) throw new PermissionError(path, "realpath");
-		return fromSandboxPath(this.basePath, resolved);
-	}
-	async readFile(path, options) {
-		await this.ready();
-		if ((await this.stat(path)).type === "directory") throw new IsDirectoryError(path);
-		try {
-			const content = Buffer.from(await this.sandbox.sandboxSdk.files.read(toSandboxPath(this.basePath, path)));
-			return options?.encoding ? content.toString(options.encoding) : content;
-		} catch (error) {
-			throw mapFileError(path, "read", error);
-		}
-	}
-	async writeFile(path, content, options) {
-		await this.ready();
-		this.assertWritable("writeFile");
-		const target = toSandboxPath(this.basePath, path);
-		const exists = await this.exists(path);
-		if (exists && options?.overwrite === false) throw new FileExistsError(path);
-		if (exists) {
-			const current = await this.stat(path);
-			if (current.type === "directory") throw new IsDirectoryError(path);
-			if (options?.expectedMtime && current.modifiedAt.getTime() !== options.expectedMtime.getTime()) throw new StaleFileError(path, options.expectedMtime, current.modifiedAt);
-		}
-		await this.ensureParent(path, options?.recursive !== false);
-		try {
-			await this.sandbox.sandboxSdk.files.write(target, toBytes(content));
-		} catch (error) {
-			throw mapFileError(path, "write", error);
-		}
-	}
-	async appendFile(path, content) {
-		await this.ready();
-		this.assertWritable("appendFile");
-		const current = await this.exists(path) ? Buffer.from(await this.readFile(path)) : Buffer.alloc(0);
-		const added = Buffer.from(toBytes(content));
-		const combined = new Uint8Array(current.byteLength + added.byteLength);
-		combined.set(current);
-		combined.set(added, current.byteLength);
-		await this.writeFile(path, combined);
-	}
-	async deleteFile(path, options) {
-		await this.ready();
-		this.assertWritable("deleteFile");
-		if (!await this.exists(path)) {
-			if (options?.force) return;
-			throw new FileNotFoundError(path);
-		}
-		if ((await this.stat(path)).type === "directory") throw new IsDirectoryError(path);
-		try {
-			await this.sandbox.sandboxSdk.files.remove(toSandboxPath(this.basePath, path));
-		} catch (error) {
-			throw mapFileError(path, "delete", error);
-		}
-	}
-	async copyFile(src, dest, options) {
-		await this.ready();
-		this.assertWritable("copyFile");
-		if (!await this.exists(src)) throw new FileNotFoundError(src);
-		if (await this.exists(dest) && options?.overwrite === false) throw new FileExistsError(dest);
-		if ((await this.stat(src)).type === "directory") {
-			if (!options?.recursive) throw new IsDirectoryError(src);
-			await this.mkdir(dest, { recursive: true });
-			for (const entry of await this.readdir(src)) await this.copyFile(joinVirtual(src, entry.name), joinVirtual(dest, entry.name), options);
-			return;
-		}
-		await this.writeFile(dest, await this.readFile(src), {
-			recursive: true,
-			overwrite: options?.overwrite
-		});
-	}
-	async moveFile(src, dest, options) {
-		this.assertWritable("moveFile");
-		const source = await this.stat(src);
-		await this.copyFile(src, dest, {
-			...options,
-			recursive: source.type === "directory" ? true : options?.recursive
-		});
-		if (source.type === "directory") await this.rmdir(src, { recursive: true });
-		else await this.deleteFile(src);
-	}
-	async mkdir(path, options) {
-		await this.ready();
-		this.assertWritable("mkdir");
-		if (await this.exists(path)) {
-			if ((await this.stat(path)).type !== "directory") throw new FileExistsError(path);
-			return;
-		}
-		if (options?.recursive === false) await this.requireParent(path);
-		try {
-			await this.sandbox.sandboxSdk.files.mkdir(toSandboxPath(this.basePath, path));
-		} catch (error) {
-			throw mapFileError(path, "mkdir", error);
-		}
-	}
-	async rmdir(path, options) {
-		await this.ready();
-		this.assertWritable("rmdir");
-		if (!await this.exists(path)) {
-			if (options?.force) return;
-			throw new DirectoryNotFoundError(path);
-		}
-		if ((await this.stat(path)).type !== "directory") throw new NotDirectoryError(path);
-		if (!options?.recursive && (await this.readdir(path)).length > 0) throw new DirectoryNotEmptyError(path);
-		try {
-			await this.sandbox.sandboxSdk.files.remove(toSandboxPath(this.basePath, path));
-		} catch (error) {
-			throw mapFileError(path, "rmdir", error);
-		}
-	}
-	async readdir(path, options) {
-		await this.ready();
-		if (!await this.exists(path)) throw new DirectoryNotFoundError(path);
-		if ((await this.stat(path)).type !== "directory") throw new NotDirectoryError(path);
-		const extensions = options?.extension ? new Set((Array.isArray(options.extension) ? options.extension : [options.extension]).map((extension$1) => extension$1.startsWith(".") ? extension$1 : `.${extension$1}`)) : void 0;
-		return this.listDirectory(path, options?.recursive ? options.maxDepth ?? 100 : 0, extensions);
-	}
-	async exists(path) {
-		await this.ready();
-		return this.sandbox.sandboxSdk.files.exists(toSandboxPath(this.basePath, path));
-	}
-	async stat(path) {
-		await this.ready();
-		const virtual = toVirtualPath(this.basePath, path);
-		const target = toSandboxPath(this.basePath, virtual);
-		if (virtual === "/") return directoryStat("", "/");
-		if (!await this.sandbox.sandboxSdk.files.exists(target)) throw new FileNotFoundError(path);
-		const native = await this.nativeStat(target);
-		if (native) return {
-			name: basename(virtual),
-			path: virtual,
-			type: native.type,
-			size: native.size,
-			createdAt: native.createdAt,
-			modifiedAt: native.modifiedAt
-		};
-		const entry = await this.findEntry(target);
-		if (!entry) throw new FileNotFoundError(path);
-		const timestamp = /* @__PURE__ */ new Date(0);
-		return {
-			name: entry.name,
-			path: virtual,
-			type: entry.type === "directory" ? "directory" : "file",
-			size: entry.size ?? 0,
-			createdAt: timestamp,
-			modifiedAt: timestamp
-		};
-	}
-	async ready() {
-		await this.ensureReady();
-		await this.sandbox.ensureRunning();
-	}
-	assertWritable(operation) {
-		if (this.readOnly) throw new WorkspaceReadOnlyError(operation);
-	}
-	async ensureParent(path, recursive) {
-		const parent = dirname(toVirtualPath(this.basePath, path));
-		if (parent === "/") return;
-		if (recursive) await this.mkdir(parent, { recursive: true });
-		else await this.requireParent(path);
-	}
-	async requireParent(path) {
-		const parent = dirname(toVirtualPath(this.basePath, path));
-		if (!await this.exists(parent)) throw new DirectoryNotFoundError(parent);
-		if ((await this.stat(parent)).type !== "directory") throw new NotDirectoryError(parent);
-	}
-	async listDirectory(path, depth, extensions) {
-		const entries = await this.sandbox.sandboxSdk.files.list(toSandboxPath(this.basePath, path));
-		const result = [];
-		for (const entry of entries) {
-			const type = entry.type === "directory" ? "directory" : "file";
-			if (type === "file" && extensions && !extensions.has(extension(entry.name))) continue;
-			result.push({
-				name: entry.name,
-				type,
-				...entry.size === void 0 ? {} : { size: entry.size },
-				...entry.type === "symlink" ? { isSymlink: true } : {}
-			});
-			if (depth > 0 && type === "directory") {
-				const childPath = joinVirtual(path, entry.name);
-				const children = await this.listDirectory(childPath, depth - 1, extensions);
-				result.push(...children.map((child) => ({
-					...child,
-					name: `${entry.name}/${child.name}`
-				})));
-			}
-		}
-		return result;
-	}
-	async findEntry(target) {
-		const parent = dirname(target);
-		return (await this.sandbox.sandboxSdk.files.list(parent)).find((entry) => entry.path === target);
-	}
-	async nativeStat(target) {
-		try {
-			const result = await this.sandbox.sandboxSdk.run({
-				command: "stat",
-				args: [
-					"-c",
-					"%F|%s|%W|%Y",
-					target
-				]
-			});
-			if (!result.success) return void 0;
-			const [kind, sizeValue, createdValue, modifiedValue] = result.stdout.trim().split("|");
-			if (!kind || !sizeValue || !createdValue || !modifiedValue) return;
-			const modified = Number(modifiedValue) * 1e3;
-			const createdSeconds = Number(createdValue);
-			return {
-				type: kind.includes("directory") ? "directory" : "file",
-				size: Number(sizeValue),
-				createdAt: /* @__PURE__ */ new Date((createdSeconds > 0 ? createdSeconds : Number(modifiedValue)) * 1e3),
-				modifiedAt: new Date(modified)
-			};
-		} catch {
-			return;
-		}
-	}
-};
-function requireManaged(provider) {
-	if (!provider.managed) throw new SandboxError({
-		code: "unsupported",
-		provider: provider.id,
-		operation: "mastra.createSandbox",
-		message: `Provider ${provider.id} does not implement managed sandbox sessions`
-	});
-	return provider.managed;
-}
-function normalizeCwd(value) {
-	if (!value.startsWith("/") || value.includes("\0")) throw new SandboxError({
-		code: "invalid_input",
-		provider: "mastra",
-		operation: "cwd",
-		message: "cwd must be an absolute path"
-	});
-	return value.replace(/\/$/, "") || "/";
-}
-function toVirtualPath(cwd, value) {
-	assertPath(value);
-	if (value === cwd) return "/";
-	if (value.startsWith(`${cwd}/`)) return `/${value.slice(cwd.length + 1)}`;
-	return (value.startsWith("/") ? value : `/${value}`).replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
-}
-function toSandboxPath(cwd, value) {
-	const virtual = toVirtualPath(cwd, value);
-	return virtual === "/" ? cwd : `${cwd}${virtual}`;
-}
-function fromSandboxPath(cwd, value) {
-	if (value === cwd) return "/";
-	if (!value.startsWith(`${cwd}/`)) throw new PermissionError(value, "access");
-	return `/${value.slice(cwd.length + 1)}`;
-}
-function assertPath(value) {
-	if (!value || value.includes("\0") || value.split("/").includes("..")) throw new PermissionError(value, "access");
-}
-function isWithin(root, path) {
-	return path === root || path.startsWith(`${root}/`);
-}
-function toBytes(content) {
-	return typeof content === "string" ? new TextEncoder().encode(content) : new Uint8Array(content);
-}
-function basename(path) {
-	return path.split("/").filter(Boolean).at(-1) ?? "";
-}
-function dirname(path) {
-	const parts = path.split("/").filter(Boolean);
-	parts.pop();
-	return `/${parts.join("/")}`.replace(/\/$/, "") || "/";
-}
-function joinVirtual(parent, child) {
-	return `${parent.replace(/\/$/, "")}/${child}`.replace(/\/{2,}/g, "/");
-}
-function extension(path) {
-	const name = basename(path);
-	const index = name.lastIndexOf(".");
-	return index <= 0 ? "" : name.slice(index);
-}
-/**
-* Preserve argument boundaries for ordinary commands. Commands that use shell
-* syntax deliberately fall back to the provider's shell-string execution path.
-*/
-function parseSimpleCommand(value) {
-	const parts = [];
-	let current = "";
-	let tokenStarted = false;
-	let quote;
-	const finish = () => {
-		if (!tokenStarted) return;
-		parts.push(current);
-		current = "";
-		tokenStarted = false;
-	};
-	for (let index = 0; index < value.length; index++) {
-		const character = value[index];
-		if (quote === "single") {
-			if (character === "'") quote = void 0;
-			else current += character;
-			tokenStarted = true;
-			continue;
-		}
-		if (quote === "double") {
-			if (character === "\"") quote = void 0;
-			else if (character === "\\") {
-				const next = value[++index];
-				if (next === void 0) return void 0;
-				current += next;
-			} else if (character === "$" || character === "`") return;
-			else current += character;
-			tokenStarted = true;
-			continue;
-		}
-		if (/\s/.test(character)) {
-			finish();
-			continue;
-		}
-		if (character === "'") {
-			quote = "single";
-			tokenStarted = true;
-			continue;
-		}
-		if (character === "\"") {
-			quote = "double";
-			tokenStarted = true;
-			continue;
-		}
-		if (character === "\\") {
-			const next = value[++index];
-			if (next === void 0) return void 0;
-			current += next;
-			tokenStarted = true;
-			continue;
-		}
-		if ("|&;<>()$`*?[]{}~#\n\r".includes(character)) return void 0;
-		current += character;
-		tokenStarted = true;
-	}
-	if (quote) return void 0;
-	finish();
-	const [command, ...args] = parts;
-	return command ? {
-		command,
-		args
-	} : void 0;
-}
-function directoryStat(name, path) {
-	const timestamp = /* @__PURE__ */ new Date(0);
-	return {
-		name,
-		path,
-		type: "directory",
-		size: 0,
-		createdAt: timestamp,
-		modifiedAt: timestamp
-	};
-}
-function mapFileError(path, operation, error) {
-	if (!isSandboxError(error)) return error instanceof Error ? error : new Error(String(error));
-	if (error.code === "not_found") return new FileNotFoundError(path);
-	if (error.code === "permission") return new PermissionError(path, operation);
-	if (error.code === "conflict") return new FileExistsError(path);
-	return error;
-}
-
-//#endregion
-export { SandboxSDKMastraFilesystem, SandboxSDKMastraSandbox, SandboxSDKProcessManager, createMastraSandbox, createMastraWorkspace };
-//# sourceMappingURL=index.mjs.map