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

package/dist/eve/index.mjs

@@ -1,155 +0,0 @@
-import { n as isSandboxError, t as SandboxError } from "../errors-BuF9bYOQ.mjs";
-import { r as toAISandboxSession } from "../ai-DeFa8yPk.mjs";
-
-//#region src/eve/index.ts
-/** Create an Eve beta SandboxBackend backed by a managed sandbox-sdk provider. */
-function createEveSandboxBackend(options) {
-	const managed = requireManaged(options.provider);
-	const prewarmed = /* @__PURE__ */ new Set();
-	return {
-		name: `sandbox-sdk-${options.provider.id}`,
-		async prewarm(input) {
-			if (prewarmed.has(input.templateKey)) return { reused: true };
-			input.log?.(`Preparing ${options.provider.id} sandbox template ${input.templateKey}`);
-			await (await managed.create({
-				sessionId: templateSessionId(input.templateKey),
-				identity: input.templateKey,
-				cwd: options.cwd,
-				env: options.env,
-				ports: options.ports,
-				onFirstCreate: async (sandbox) => {
-					await Promise.all(input.seedFiles.map((file) => sandbox.files.write(resolveSandboxPath(sandbox.cwd, file.path), file.content)));
-					if (input.bootstrap) {
-						const templateView = {
-							id: templateSessionId(input.templateKey),
-							sandbox,
-							defaultWorkingDirectory: sandbox.cwd,
-							ports: options.ports ?? [],
-							getPortUrl: async () => {
-								throw new Error("Template ports are not available during prewarm");
-							},
-							stop: async () => {},
-							resume: async () => {},
-							destroy: async () => {}
-						};
-						await input.bootstrap({ use: createUseFn(templateView) });
-					}
-				}
-			})).destroy();
-			prewarmed.add(input.templateKey);
-			return { reused: false };
-		},
-		async create(input) {
-			const reconnectId = readString(input.existingMetadata, "managedSessionId");
-			let managedSession;
-			if (reconnectId) managedSession = await managed.resume({ sessionId: reconnectId });
-			else managedSession = await managed.create({
-				sessionId: input.sessionKey,
-				identity: input.templateKey ?? void 0,
-				cwd: options.cwd,
-				env: options.env,
-				ports: options.ports
-			});
-			return createHandle(managedSession, createUseFn(managedSession), options.provider.id);
-		}
-	};
-}
-function createHandle(managed, useSessionFn, providerId) {
-	return {
-		session: toEveSession(managed, providerId),
-		useSessionFn,
-		async captureState() {
-			return {
-				backendName: `sandbox-sdk-${providerId}`,
-				sessionKey: managed.id,
-				metadata: {
-					managedSessionId: managed.id,
-					provider: providerId
-				}
-			};
-		},
-		shutdown: () => managed.stop()
-	};
-}
-function createUseFn(managed) {
-	const session = toEveSession(managed, managed.sandbox.provider);
-	return async (options) => {
-		if (options?.networkPolicy !== void 0) {
-			if (!managed.setNetworkPolicy) throw unsupportedNetwork(managed.sandbox.provider);
-			await managed.setNetworkPolicy(toCoreNetworkPolicy(options.networkPolicy));
-		}
-		return session;
-	};
-}
-function toEveSession(managed, providerId) {
-	const ai = toAISandboxSession(managed.sandbox);
-	return {
-		run: ai.run,
-		spawn: ai.spawn,
-		readFile: ai.readFile,
-		readBinaryFile: ai.readBinaryFile,
-		readTextFile: ai.readTextFile,
-		writeFile: ai.writeFile,
-		writeBinaryFile: ai.writeBinaryFile,
-		writeTextFile: ai.writeTextFile,
-		id: managed.id,
-		resolvePath: (path) => resolveSandboxPath(managed.defaultWorkingDirectory, path),
-		async removePath({ path, force }) {
-			try {
-				await managed.sandbox.files.remove(resolveSandboxPath(managed.defaultWorkingDirectory, path));
-			} catch (error) {
-				if (force && isSandboxError(error) && error.code === "not_found") return;
-				throw error;
-			}
-		},
-		async setNetworkPolicy(policy) {
-			if (!managed.setNetworkPolicy) throw unsupportedNetwork(providerId);
-			await managed.setNetworkPolicy(toCoreNetworkPolicy(policy));
-		}
-	};
-}
-function toCoreNetworkPolicy(policy) {
-	if (policy === "allow-all") return { mode: "allow-all" };
-	if (policy === "deny-all") return { mode: "deny-all" };
-	return {
-		mode: "native",
-		value: policy
-	};
-}
-function resolveSandboxPath(cwd, path) {
-	if (path.includes("\0") || path.split("/").includes("..")) throw new SandboxError({
-		code: "invalid_input",
-		provider: "eve",
-		operation: "resolvePath",
-		message: `Invalid sandbox path: ${path}`
-	});
-	return path.startsWith("/") ? path : `${cwd.replace(/\/$/, "")}/${path}`;
-}
-function templateSessionId(templateKey) {
-	return `eve-template-${templateKey}`;
-}
-function readString(record, key) {
-	const value = record?.[key];
-	return typeof value === "string" ? value : void 0;
-}
-function unsupportedNetwork(provider) {
-	return new SandboxError({
-		code: "unsupported",
-		provider,
-		operation: "network.policy",
-		message: `Provider ${provider} does not support network-policy mutation`
-	});
-}
-function requireManaged(provider) {
-	if (!provider.managed) throw new SandboxError({
-		code: "unsupported",
-		provider: provider.id,
-		operation: "eve.createBackend",
-		message: `Provider ${provider.id} does not implement managed sandbox sessions`
-	});
-	return provider.managed;
-}
-
-//#endregion
-export { createEveSandboxBackend };
-//# sourceMappingURL=index.mjs.map

package/dist/eve/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":["templateView: ManagedSandboxSession","managedSession: ManagedSandboxSession"],"sources":["../../src/eve/index.ts"],"sourcesContent":["import type {\n  SandboxBackend,\n  SandboxBackendHandle,\n  SandboxNetworkPolicy as EveNetworkPolicy,\n  SandboxSession as EveSandboxSession,\n} from \"eve/sandbox\";\nimport { isSandboxError, SandboxError } from \"../core/errors\";\nimport type {\n  ManagedSandboxProvider,\n  ManagedSandboxSession,\n  SandboxNetworkPolicy,\n  SandboxProvider,\n} from \"../core/provider\";\nimport { toAISandboxSession } from \"../ai/index\";\n\nexport interface EveSandboxUseOptions {\n  networkPolicy?: EveNetworkPolicy;\n}\n\nexport interface CreateEveSandboxBackendOptions {\n  provider: SandboxProvider<unknown>;\n  ports?: ReadonlyArray<number>;\n  cwd?: string;\n  env?: Readonly<Record<string, string>>;\n}\n\n/** Create an Eve beta SandboxBackend backed by a managed sandbox-sdk provider. */\nexport function createEveSandboxBackend(\n  options: CreateEveSandboxBackendOptions,\n): SandboxBackend<EveSandboxUseOptions, EveSandboxUseOptions> {\n  const managed = requireManaged(options.provider);\n  const prewarmed = new Set<string>();\n\n  return {\n    name: `sandbox-sdk-${options.provider.id}`,\n    async prewarm(input) {\n      if (prewarmed.has(input.templateKey)) return { reused: true };\n      input.log?.(`Preparing ${options.provider.id} sandbox template ${input.templateKey}`);\n      const template = await managed.create({\n        sessionId: templateSessionId(input.templateKey),\n        identity: input.templateKey,\n        cwd: options.cwd,\n        env: options.env,\n        ports: options.ports,\n        onFirstCreate: async (sandbox) => {\n          await Promise.all(\n            input.seedFiles.map((file) =>\n              sandbox.files.write(resolveSandboxPath(sandbox.cwd, file.path), file.content),\n            ),\n          );\n          if (input.bootstrap) {\n            const templateView: ManagedSandboxSession = {\n              id: templateSessionId(input.templateKey),\n              sandbox,\n              defaultWorkingDirectory: sandbox.cwd,\n              ports: options.ports ?? [],\n              getPortUrl: async () => {\n                throw new Error(\"Template ports are not available during prewarm\");\n              },\n              stop: async () => {},\n              resume: async () => {},\n              destroy: async () => {},\n            };\n            await input.bootstrap({ use: createUseFn(templateView) });\n          }\n        },\n      });\n      await template.destroy();\n      prewarmed.add(input.templateKey);\n      return { reused: false };\n    },\n    async create(input) {\n      const reconnectId = readString(input.existingMetadata, \"managedSessionId\");\n      let managedSession: ManagedSandboxSession;\n      if (reconnectId) {\n        managedSession = await managed.resume({ sessionId: reconnectId });\n      } else {\n        managedSession = await managed.create({\n          sessionId: input.sessionKey,\n          identity: input.templateKey ?? undefined,\n          cwd: options.cwd,\n          env: options.env,\n          ports: options.ports,\n        });\n      }\n      return createHandle(managedSession, createUseFn(managedSession), options.provider.id);\n    },\n  };\n}\n\nfunction createHandle(\n  managed: ManagedSandboxSession,\n  useSessionFn: (options?: EveSandboxUseOptions) => Promise<EveSandboxSession>,\n  providerId: string,\n): SandboxBackendHandle<EveSandboxUseOptions> {\n  return {\n    session: toEveSession(managed, providerId),\n    useSessionFn,\n    async captureState() {\n      return {\n        backendName: `sandbox-sdk-${providerId}`,\n        sessionKey: managed.id,\n        metadata: { managedSessionId: managed.id, provider: providerId },\n      };\n    },\n    shutdown: () => managed.stop(),\n  };\n}\n\nfunction createUseFn(managed: ManagedSandboxSession) {\n  const session = toEveSession(managed, managed.sandbox.provider);\n  return async (options?: EveSandboxUseOptions): Promise<EveSandboxSession> => {\n    if (options?.networkPolicy !== undefined) {\n      if (!managed.setNetworkPolicy) throw unsupportedNetwork(managed.sandbox.provider);\n      await managed.setNetworkPolicy(toCoreNetworkPolicy(options.networkPolicy));\n    }\n    return session;\n  };\n}\n\nfunction toEveSession(managed: ManagedSandboxSession, providerId: string): EveSandboxSession {\n  const ai = toAISandboxSession(managed.sandbox);\n  return {\n    run: ai.run,\n    spawn: ai.spawn,\n    readFile: ai.readFile,\n    readBinaryFile: ai.readBinaryFile,\n    readTextFile: ai.readTextFile,\n    writeFile: ai.writeFile,\n    writeBinaryFile: ai.writeBinaryFile,\n    writeTextFile: ai.writeTextFile,\n    id: managed.id,\n    resolvePath: (path) => resolveSandboxPath(managed.defaultWorkingDirectory, path),\n    async removePath({ path, force }) {\n      try {\n        await managed.sandbox.files.remove(\n          resolveSandboxPath(managed.defaultWorkingDirectory, path),\n        );\n      } catch (error) {\n        if (force && isSandboxError(error) && error.code === \"not_found\") return;\n        throw error;\n      }\n    },\n    async setNetworkPolicy(policy) {\n      if (!managed.setNetworkPolicy) throw unsupportedNetwork(providerId);\n      await managed.setNetworkPolicy(toCoreNetworkPolicy(policy));\n    },\n  };\n}\n\nfunction toCoreNetworkPolicy(policy: EveNetworkPolicy): SandboxNetworkPolicy {\n  if (policy === \"allow-all\") return { mode: \"allow-all\" };\n  if (policy === \"deny-all\") return { mode: \"deny-all\" };\n  return { mode: \"native\", value: policy };\n}\n\nfunction resolveSandboxPath(cwd: string, path: string): string {\n  if (path.includes(\"\\0\") || path.split(\"/\").includes(\"..\")) {\n    throw new SandboxError({\n      code: \"invalid_input\",\n      provider: \"eve\",\n      operation: \"resolvePath\",\n      message: `Invalid sandbox path: ${path}`,\n    });\n  }\n  return path.startsWith(\"/\") ? path : `${cwd.replace(/\\/$/, \"\")}/${path}`;\n}\n\nfunction templateSessionId(templateKey: string): string {\n  return `eve-template-${templateKey}`;\n}\n\nfunction readString(record: Record<string, unknown> | undefined, key: string): string | undefined {\n  const value = record?.[key];\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction unsupportedNetwork(provider: string): SandboxError {\n  return new SandboxError({\n    code: \"unsupported\",\n    provider,\n    operation: \"network.policy\",\n    message: `Provider ${provider} does not support network-policy mutation`,\n  });\n}\n\nfunction requireManaged(provider: SandboxProvider<unknown>): ManagedSandboxProvider {\n  if (!provider.managed) {\n    throw new SandboxError({\n      code: \"unsupported\",\n      provider: provider.id,\n      operation: \"eve.createBackend\",\n      message: `Provider ${provider.id} does not implement managed sandbox sessions`,\n    });\n  }\n  return provider.managed;\n}\n\nexport type { SandboxBackend, SandboxBackendHandle, EveSandboxSession };\n"],"mappings":"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"}

package/dist/index-CkTwqD0X.d.mts

@@ -1,25 +0,0 @@
-import { o as SandboxProvider } from "./provider-DOBErkBO.mjs";
-import { AgentOs, AgentOsOptions } from "@rivet-dev/agentos-core";
-
-//#region src/providers/agentos/index.d.ts
-interface AgentOsProviderOptions {
-  /**
-   * Native agentOS VM options. The provider supplies production-oriented permissions and limits
-   * unless these fields are explicitly provided.
-   */
-  agentOs?: AgentOsOptions;
-}
-interface AgentOsSandbox {
-  /** The currently running native VM. Access throws while the sandbox is suspended or stopped. */
-  readonly vm: AgentOs;
-  suspend(): Promise<void>;
-  resume(): Promise<void>;
-}
-/**
- * @deprecated AgentOS now powers `local()` under the hood. Import `local` from
- * `@opencoredev/sandbox-sdk/local` instead.
- */
-declare function agentos(options?: AgentOsProviderOptions): SandboxProvider<AgentOsSandbox>;
-//#endregion
-export { AgentOsSandbox as n, agentos as r, AgentOsProviderOptions as t };
-//# sourceMappingURL=index-CkTwqD0X.d.mts.map

package/dist/index-Dh9xob2s.d.mts

@@ -1,31 +0,0 @@
-import { f as Sandbox, r as CapabilityMode, t as Capability } from "./types-Bv6I2U1c.mjs";
-
-//#region src/core/capabilities.d.ts
-declare function supports(sandbox: Pick<Sandbox, "capabilities">, capability: Capability): boolean;
-declare function capabilityMode(sandbox: Pick<Sandbox, "capabilities">, capability: Capability): CapabilityMode | false;
-declare function requireCapability(sandbox: Pick<Sandbox, "capabilities" | "provider">, capability: Capability): CapabilityMode;
-//#endregion
-//#region src/core/errors.d.ts
-declare const sandboxErrorCodes: readonly ["authentication", "permission", "not_found", "timeout", "rate_limited", "unavailable", "unsupported", "invalid_input", "conflict", "terminated", "process_failed", "internal"];
-type SandboxErrorCode = (typeof sandboxErrorCodes)[number];
-declare function redactSensitive(value: string): string;
-declare class SandboxError extends Error {
-  readonly code: SandboxErrorCode;
-  readonly provider: string;
-  readonly operation?: string;
-  readonly retryable: boolean;
-  readonly cause?: unknown;
-  constructor(options: {
-    code: SandboxErrorCode;
-    provider: string;
-    message: string;
-    operation?: string;
-    retryable?: boolean;
-    cause?: unknown;
-  });
-  toString(): string;
-}
-declare function isSandboxError(error: unknown): error is SandboxError;
-//#endregion
-export { sandboxErrorCodes as a, supports as c, redactSensitive as i, SandboxErrorCode as n, capabilityMode as o, isSandboxError as r, requireCapability as s, SandboxError as t };
-//# sourceMappingURL=index-Dh9xob2s.d.mts.map

package/dist/index.d.mts

@@ -1,5 +0,0 @@
-import { _ as SandboxProcesses, a as CommandResult, b as capabilityNames, c as ProcessOutputEvent, d as RunOptions, f as Sandbox, g as SandboxProcess, h as SandboxPorts, i as CommandInput, l as ProcessStatus, m as SandboxFiles, n as CapabilityMap, o as ExposedPort, p as SandboxDirectoryEntry, r as CapabilityMode, s as FileValue, t as Capability, u as ProviderName, v as SandboxSnapshot, x as providerNames, y as SandboxSnapshots } from "./types-Bv6I2U1c.mjs";
-import { a as SandboxNetworkPolicy, i as ManagedSandboxSession, n as ManagedSandboxProvider, r as ManagedSandboxResumeOptions, t as ManagedSandboxCreateOptions } from "./provider-DOBErkBO.mjs";
-import { a as sandboxErrorCodes, c as supports, i as redactSensitive, n as SandboxErrorCode, o as capabilityMode, r as isSandboxError, s as requireCapability, t as SandboxError } from "./index-Dh9xob2s.mjs";
-import { n as createSandbox, r as withSandbox } from "./sandbox-DdEqoXJF.mjs";
-export { Capability, CapabilityMap, CapabilityMode, CommandInput, CommandResult, ExposedPort, FileValue, ManagedSandboxCreateOptions, ManagedSandboxProvider, ManagedSandboxResumeOptions, ManagedSandboxSession, ProcessOutputEvent, ProcessStatus, ProviderName, RunOptions, Sandbox, SandboxDirectoryEntry, SandboxError, SandboxErrorCode, SandboxFiles, SandboxNetworkPolicy, SandboxPorts, SandboxProcess, SandboxProcesses, SandboxSnapshot, SandboxSnapshots, capabilityMode, capabilityNames, createSandbox, isSandboxError, providerNames, redactSensitive, requireCapability, sandboxErrorCodes, supports, withSandbox };

package/dist/index.mjs

@@ -1,40 +0,0 @@
-import { a as sandboxErrorCodes, i as redactSensitive, n as isSandboxError, t as SandboxError } from "./errors-BuF9bYOQ.mjs";
-import { i as supports, r as requireCapability, t as capabilityMode } from "./capabilities-xs9kaHrK.mjs";
-import { n as withSandbox, t as createSandbox } from "./sandbox-DgtY5hvt.mjs";
-
-//#region src/core/types.ts
-const providerNames = [
-	"local",
-	"e2b",
-	"daytona",
-	"vercel",
-	"upstash",
-	"box",
-	"railway"
-];
-const capabilityNames = [
-	"files.read",
-	"files.write",
-	"files.list",
-	"files.remove",
-	"process.run",
-	"process.stream",
-	"process.background",
-	"process.stdin",
-	"process.cancel",
-	"ports.expose",
-	"ports.authenticatedRequest",
-	"snapshot.create",
-	"snapshot.delete",
-	"snapshot.restore",
-	"sandbox.resume",
-	"filesystem.persistent",
-	"image.custom",
-	"network.policy",
-	"process.pty",
-	"compute.gpu"
-];
-
-//#endregion
-export { SandboxError, capabilityMode, capabilityNames, createSandbox, isSandboxError, providerNames, redactSensitive, requireCapability, sandboxErrorCodes, supports, withSandbox };
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/core/types.ts"],"sourcesContent":["export const providerNames = [\n  \"local\",\n  \"e2b\",\n  \"daytona\",\n  \"vercel\",\n  \"upstash\",\n  \"box\",\n  \"railway\",\n] as const;\nexport type ProviderName = (typeof providerNames)[number];\n\nexport const capabilityNames = [\n  \"files.read\",\n  \"files.write\",\n  \"files.list\",\n  \"files.remove\",\n  \"process.run\",\n  \"process.stream\",\n  \"process.background\",\n  \"process.stdin\",\n  \"process.cancel\",\n  \"ports.expose\",\n  \"ports.authenticatedRequest\",\n  \"snapshot.create\",\n  \"snapshot.delete\",\n  \"snapshot.restore\",\n  \"sandbox.resume\",\n  \"filesystem.persistent\",\n  \"image.custom\",\n  \"network.policy\",\n  \"process.pty\",\n  \"compute.gpu\",\n] as const;\n\nexport type Capability = (typeof capabilityNames)[number];\nexport type CapabilityMode =\n  | \"filesystem\"\n  | \"memory\"\n  | \"template\"\n  | \"fork\"\n  | \"public\"\n  | \"authenticated\"\n  | \"combined-stream\"\n  | \"separate-streams\"\n  | \"ephemeral\"\n  | \"persistent\"\n  | \"localhost\"\n  | \"in-process\"\n  | \"full\"\n  | \"native\";\n\nexport type CapabilityMap = Readonly<Record<Capability, false | CapabilityMode>>;\n\nexport type CommandInput = string | { command: string; args?: readonly string[] };\n\nexport interface RunOptions {\n  cwd?: string;\n  env?: Readonly<Record<string, string>>;\n  timeout?: number;\n  signal?: AbortSignal;\n}\n\nexport interface CommandResult {\n  stdout: string;\n  stderr: string;\n  exitCode: number;\n  success: boolean;\n  signal?: string;\n  durationMs?: number;\n}\n\nexport type FileValue = string | Uint8Array | ArrayBuffer | Blob | ReadableStream<Uint8Array>;\n\nexport interface SandboxDirectoryEntry {\n  name: string;\n  path: string;\n  type: \"file\" | \"directory\" | \"symlink\" | \"unknown\";\n  size?: number;\n}\n\nexport interface SandboxFiles {\n  write(path: string, value: FileValue): Promise<void>;\n  read(path: string): Promise<Uint8Array>;\n  text(path: string): Promise<string>;\n  list(path?: string): Promise<SandboxDirectoryEntry[]>;\n  mkdir(path: string): Promise<void>;\n  remove(path: string): Promise<void>;\n  exists(path: string): Promise<boolean>;\n}\n\nexport interface ProcessOutputEvent {\n  stream: \"stdout\" | \"stderr\";\n  data: string | Uint8Array;\n  timestamp?: Date;\n}\n\nexport type ProcessStatus = \"starting\" | \"running\" | \"exited\" | \"killed\" | \"unknown\";\n\nexport interface SandboxProcess {\n  readonly id: string;\n  status(): Promise<ProcessStatus>;\n  output(): AsyncIterable<ProcessOutputEvent>;\n  write(value: string | Uint8Array): Promise<void>;\n  wait(): Promise<{ exitCode: number }>;\n  kill(signal?: string): Promise<void>;\n}\n\nexport interface SandboxProcesses {\n  start(command: CommandInput, options?: RunOptions): Promise<SandboxProcess>;\n}\n\nexport interface ExposedPort {\n  readonly port: number;\n  readonly url: string;\n  readonly public: boolean;\n  readonly authenticated: boolean;\n  request?(path?: string, init?: RequestInit): Promise<Response>;\n  toJSON(): Omit<ExposedPort, \"request\" | \"toJSON\">;\n}\n\nexport interface SandboxPorts {\n  expose(port: number): Promise<ExposedPort>;\n}\n\nexport interface SandboxSnapshot {\n  readonly id: string;\n  readonly name?: string;\n  readonly mode: CapabilityMode;\n  readonly createdAt?: Date;\n}\n\nexport interface SandboxSnapshots {\n  create(options?: { name?: string }): Promise<SandboxSnapshot>;\n  delete(snapshot: SandboxSnapshot | string): Promise<void>;\n  restore(snapshot: SandboxSnapshot | string): Promise<void>;\n}\n\nexport interface Sandbox<TRaw = unknown> {\n  readonly id: string;\n  readonly provider: ProviderName;\n  readonly cwd: string;\n  readonly capabilities: CapabilityMap;\n  readonly raw: TRaw;\n  readonly files: SandboxFiles;\n  readonly processes: SandboxProcesses;\n  readonly ports: SandboxPorts;\n  readonly snapshots: SandboxSnapshots;\n  run(command: CommandInput, options?: RunOptions): Promise<CommandResult>;\n  /** Stops the provider runtime. Repeated calls share the same cleanup operation. */\n  stop(): Promise<void>;\n  /** Stops the sandbox when an `await using` scope exits. */\n  [Symbol.asyncDispose](): Promise<void>;\n}\n"],"mappings":";;;;;AAAA,MAAa,gBAAgB;CAC3B;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAGD,MAAa,kBAAkB;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}

package/dist/managed-provider-BsZGVQ4I.mjs

@@ -1,148 +0,0 @@
-import { t as SandboxError } from "./errors-BuF9bYOQ.mjs";
-import { t as createSandbox } from "./sandbox-DgtY5hvt.mjs";
-
-//#region src/internal/managed-provider.ts
-/**
-* Shared managed lifecycle for built-in providers. Provider-native implementations
-* can replace this optional surface without changing `createSandbox()`.
-*/
-function withManagedSessions(provider, configuredPorts = [], lifecycle = {}) {
-	const sessions = /* @__PURE__ */ new Map();
-	const templates = /* @__PURE__ */ new Map();
-	const managed = {
-		async create(options) {
-			const existing = sessions.get(options.sessionId);
-			if (existing) return existing;
-			const sandbox = await createSandbox({
-				provider,
-				cwd: options.cwd,
-				env: options.env,
-				signal: options.signal
-			});
-			const ports = new Set([...configuredPorts, ...options.ports ?? []]);
-			let ownedTemplate;
-			try {
-				if (options.identity) {
-					let template = templates.get(options.identity);
-					if (!template) {
-						template = (async () => {
-							await options.onFirstCreate?.(sandbox);
-							return captureFiles(sandbox, sandbox.cwd);
-						})();
-						ownedTemplate = template;
-						templates.set(options.identity, template);
-						await template;
-					} else await restoreFiles(sandbox, await template);
-				} else await options.onFirstCreate?.(sandbox);
-				const session = createManagedSession(options.sessionId, sandbox, ports, sessions, lifecycle);
-				sessions.set(options.sessionId, session);
-				return session;
-			} catch (error) {
-				if (options.identity && ownedTemplate && templates.get(options.identity) === ownedTemplate) templates.delete(options.identity);
-				try {
-					if (lifecycle.destroy) await lifecycle.destroy(sandbox);
-					else await sandbox.stop();
-				} catch (cleanupError) {
-					if (error instanceof Error) Object.defineProperty(error, "cleanupError", {
-						value: cleanupError,
-						enumerable: false
-					});
-				}
-				throw error;
-			}
-		},
-		async resume(options) {
-			const session = sessions.get(options.sessionId);
-			if (!session) throw new SandboxError({
-				code: "not_found",
-				provider: provider.id,
-				operation: "managed.resume",
-				message: `Managed sandbox session not found: ${options.sessionId}`
-			});
-			await session.resume();
-			return session;
-		}
-	};
-	return {
-		...provider,
-		managed
-	};
-}
-function createManagedSession(id, sandbox, initialPorts, sessions, lifecycle) {
-	let destroyed = false;
-	let stopped = false;
-	const assertActive = () => {
-		if (destroyed) throw new SandboxError({
-			code: "terminated",
-			provider: sandbox.provider,
-			operation: "managed.session",
-			message: `Managed sandbox session has been destroyed: ${id}`
-		});
-	};
-	return {
-		id,
-		sandbox,
-		defaultWorkingDirectory: sandbox.cwd,
-		get ports() {
-			return [...initialPorts];
-		},
-		async getPortUrl({ port, protocol }) {
-			assertActive();
-			if (!initialPorts.has(port)) throw new SandboxError({
-				code: "invalid_input",
-				provider: sandbox.provider,
-				operation: "managed.getPortUrl",
-				message: `Port ${port} is not exposed by this session`
-			});
-			const exposed = await sandbox.ports.expose(port);
-			const url = new URL(exposed.url);
-			if (protocol) url.protocol = `${protocol}:`;
-			return url.toString().replace(/\/$/, "");
-		},
-		async stop() {
-			assertActive();
-			if (stopped) return;
-			await lifecycle.stop?.(sandbox);
-			stopped = true;
-		},
-		async resume() {
-			assertActive();
-			if (!stopped) return;
-			await lifecycle.resume?.(sandbox);
-			stopped = false;
-		},
-		async destroy() {
-			if (destroyed) return;
-			destroyed = true;
-			sessions.delete(id);
-			if (lifecycle.destroy) await lifecycle.destroy(sandbox);
-			else await sandbox.stop();
-		},
-		...lifecycle.setPorts ? { async setPorts(ports, options) {
-			assertActive();
-			await lifecycle.setPorts(sandbox, ports, options?.signal);
-			initialPorts.clear();
-			for (const port of ports) initialPorts.add(port);
-		} } : {},
-		...lifecycle.setNetworkPolicy ? { setNetworkPolicy: (policy) => {
-			assertActive();
-			return lifecycle.setNetworkPolicy(sandbox, policy);
-		} } : {}
-	};
-}
-async function captureFiles(sandbox, path) {
-	const result = [];
-	for (const entry of await sandbox.files.list(path)) if (entry.type === "directory") result.push(...await captureFiles(sandbox, entry.path));
-	else if (entry.type === "file") result.push({
-		path: entry.path,
-		content: await sandbox.files.read(entry.path)
-	});
-	return result;
-}
-async function restoreFiles(sandbox, files) {
-	await Promise.all(files.map((file) => sandbox.files.write(file.path, file.content)));
-}
-
-//#endregion
-export { withManagedSessions as t };
-//# sourceMappingURL=managed-provider-BsZGVQ4I.mjs.map

package/dist/managed-provider-BsZGVQ4I.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"managed-provider-BsZGVQ4I.mjs","names":["managed: ManagedSandboxProvider","ownedTemplate: Promise<TemplateFile[]> | undefined","result: TemplateFile[]"],"sources":["../src/internal/managed-provider.ts"],"sourcesContent":["import { SandboxError } from \"../core/errors\";\nimport type {\n  ManagedSandboxProvider,\n  ManagedSandboxSession,\n  SandboxProvider,\n} from \"../core/provider\";\nimport { createSandbox } from \"../core/sandbox\";\nimport type { Sandbox } from \"../core/types\";\nimport type { SandboxNetworkPolicy } from \"../core/provider\";\n\ntype TemplateFile = { path: string; content: Uint8Array };\n\n/**\n * Shared managed lifecycle for built-in providers. Provider-native implementations\n * can replace this optional surface without changing `createSandbox()`.\n */\nexport function withManagedSessions<TRaw>(\n  provider: SandboxProvider<TRaw>,\n  configuredPorts: ReadonlyArray<number> = [],\n  lifecycle: {\n    stop?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    resume?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    destroy?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    setPorts?: (\n      sandbox: Sandbox<TRaw>,\n      ports: ReadonlyArray<number>,\n      signal?: AbortSignal,\n    ) => Promise<void>;\n    setNetworkPolicy?: (sandbox: Sandbox<TRaw>, policy: SandboxNetworkPolicy) => Promise<void>;\n  } = {},\n): SandboxProvider<TRaw> {\n  const sessions = new Map<string, ManagedSandboxSession>();\n  const templates = new Map<string, Promise<TemplateFile[]>>();\n\n  const managed: ManagedSandboxProvider = {\n    async create(options) {\n      const existing = sessions.get(options.sessionId);\n      if (existing) return existing;\n      const sandbox = await createSandbox({\n        provider,\n        cwd: options.cwd,\n        env: options.env,\n        signal: options.signal,\n      });\n      const ports = new Set([...configuredPorts, ...(options.ports ?? [])]);\n      let ownedTemplate: Promise<TemplateFile[]> | undefined;\n      try {\n        if (options.identity) {\n          let template = templates.get(options.identity);\n          if (!template) {\n            template = (async () => {\n              await options.onFirstCreate?.(sandbox);\n              return captureFiles(sandbox, sandbox.cwd);\n            })();\n            ownedTemplate = template;\n            templates.set(options.identity, template);\n            await template;\n          } else {\n            await restoreFiles(sandbox, await template);\n          }\n        } else {\n          await options.onFirstCreate?.(sandbox);\n        }\n        const session = createManagedSession(\n          options.sessionId,\n          sandbox,\n          ports,\n          sessions,\n          lifecycle,\n        );\n        sessions.set(options.sessionId, session);\n        return session;\n      } catch (error) {\n        if (\n          options.identity &&\n          ownedTemplate &&\n          templates.get(options.identity) === ownedTemplate\n        ) {\n          templates.delete(options.identity);\n        }\n        try {\n          if (lifecycle.destroy) await lifecycle.destroy(sandbox);\n          else await sandbox.stop();\n        } catch (cleanupError) {\n          if (error instanceof Error) {\n            Object.defineProperty(error, \"cleanupError\", {\n              value: cleanupError,\n              enumerable: false,\n            });\n          }\n        }\n        throw error;\n      }\n    },\n    async resume(options) {\n      const session = sessions.get(options.sessionId);\n      if (!session) {\n        throw new SandboxError({\n          code: \"not_found\",\n          provider: provider.id,\n          operation: \"managed.resume\",\n          message: `Managed sandbox session not found: ${options.sessionId}`,\n        });\n      }\n      await session.resume();\n      return session;\n    },\n  };\n  return { ...provider, managed };\n}\n\nfunction createManagedSession<TRaw>(\n  id: string,\n  sandbox: Sandbox<TRaw>,\n  initialPorts: Set<number>,\n  sessions: Map<string, ManagedSandboxSession>,\n  lifecycle: {\n    stop?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    resume?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    destroy?: (sandbox: Sandbox<TRaw>) => Promise<void>;\n    setPorts?: (\n      sandbox: Sandbox<TRaw>,\n      ports: ReadonlyArray<number>,\n      signal?: AbortSignal,\n    ) => Promise<void>;\n    setNetworkPolicy?: (sandbox: Sandbox<TRaw>, policy: SandboxNetworkPolicy) => Promise<void>;\n  },\n): ManagedSandboxSession {\n  let destroyed = false;\n  let stopped = false;\n  const assertActive = () => {\n    if (destroyed) {\n      throw new SandboxError({\n        code: \"terminated\",\n        provider: sandbox.provider,\n        operation: \"managed.session\",\n        message: `Managed sandbox session has been destroyed: ${id}`,\n      });\n    }\n  };\n  const session: ManagedSandboxSession = {\n    id,\n    sandbox,\n    defaultWorkingDirectory: sandbox.cwd,\n    get ports() {\n      return [...initialPorts];\n    },\n    async getPortUrl({ port, protocol }) {\n      assertActive();\n      if (!initialPorts.has(port)) {\n        throw new SandboxError({\n          code: \"invalid_input\",\n          provider: sandbox.provider,\n          operation: \"managed.getPortUrl\",\n          message: `Port ${port} is not exposed by this session`,\n        });\n      }\n      const exposed = await sandbox.ports.expose(port);\n      const url = new URL(exposed.url);\n      if (protocol) url.protocol = `${protocol}:`;\n      return url.toString().replace(/\\/$/, \"\");\n    },\n    async stop() {\n      assertActive();\n      if (stopped) return;\n      await lifecycle.stop?.(sandbox);\n      stopped = true;\n    },\n    async resume() {\n      assertActive();\n      if (!stopped) return;\n      await lifecycle.resume?.(sandbox);\n      stopped = false;\n    },\n    async destroy() {\n      if (destroyed) return;\n      destroyed = true;\n      sessions.delete(id);\n      if (lifecycle.destroy) await lifecycle.destroy(sandbox);\n      else await sandbox.stop();\n    },\n    ...(lifecycle.setPorts\n      ? {\n          async setPorts(ports: ReadonlyArray<number>, options?: { signal?: AbortSignal }) {\n            assertActive();\n            await lifecycle.setPorts!(sandbox, ports, options?.signal);\n            initialPorts.clear();\n            for (const port of ports) initialPorts.add(port);\n          },\n        }\n      : {}),\n    ...(lifecycle.setNetworkPolicy\n      ? {\n          setNetworkPolicy: (policy: SandboxNetworkPolicy) => {\n            assertActive();\n            return lifecycle.setNetworkPolicy!(sandbox, policy);\n          },\n        }\n      : {}),\n  };\n  return session;\n}\n\nasync function captureFiles(sandbox: Sandbox, path: string): Promise<TemplateFile[]> {\n  const result: TemplateFile[] = [];\n  for (const entry of await sandbox.files.list(path)) {\n    if (entry.type === \"directory\") result.push(...(await captureFiles(sandbox, entry.path)));\n    else if (entry.type === \"file\")\n      result.push({\n        path: entry.path,\n        content: await sandbox.files.read(entry.path),\n      });\n  }\n  return result;\n}\n\nasync function restoreFiles(sandbox: Sandbox, files: ReadonlyArray<TemplateFile>): Promise<void> {\n  await Promise.all(files.map((file) => sandbox.files.write(file.path, file.content)));\n}\n"],"mappings":"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"}

package/dist/mastra/index.d.mts

@@ -1,118 +0,0 @@
-import { f as Sandbox } from "../types-Bv6I2U1c.mjs";
-import { o as SandboxProvider } from "../provider-DOBErkBO.mjs";
-import { CopyOptions, FileContent, FileEntry, FilesystemInfo, InstructionsOption, ListOptions, MastraFilesystem, MastraFilesystemOptions, MastraSandbox, MastraSandboxOptions, ProcessHandle, ProcessInfo, ProviderStatus, ReadOptions, RemoveOptions, SandboxInfo, SandboxProcessManager, SpawnProcessOptions, Workspace, WorkspaceConfig, WriteOptions } from "@mastra/core/workspace";
-import { RequestContext } from "@mastra/core/di";
-
-//#region src/mastra/index.d.ts
-type WorkspaceOptions = Omit<WorkspaceConfig<SandboxSDKMastraFilesystem, SandboxSDKMastraSandbox>, "filesystem" | "sandbox" | "mounts">;
-interface CreateMastraSandboxOptions extends Omit<MastraSandboxOptions, "processes"> {
-  provider: SandboxProvider<unknown>;
-  id?: string;
-  identity?: string;
-  cwd?: string;
-  env?: Readonly<Record<string, string>>;
-  ports?: ReadonlyArray<number>;
-  instructions?: InstructionsOption;
-  onFirstCreate?: (sandbox: Sandbox) => void | Promise<void>;
-}
-interface CreateMastraWorkspaceOptions extends CreateMastraSandboxOptions {
-  filesystem?: Omit<CreateMastraFilesystemOptions, "sandbox">;
-  workspace?: WorkspaceOptions;
-}
-interface CreateMastraFilesystemOptions extends MastraFilesystemOptions {
-  sandbox: SandboxSDKMastraSandbox;
-  readOnly?: boolean;
-  instructions?: InstructionsOption;
-}
-/** Create a Mastra sandbox backed by any managed Sandbox SDK provider. */
-declare function createMastraSandbox(options: CreateMastraSandboxOptions): SandboxSDKMastraSandbox;
-/**
- * Create a Mastra workspace whose filesystem and commands share one Sandbox SDK
- * session. The workspace owns and destroys the session.
- */
-declare function createMastraWorkspace(options: CreateMastraWorkspaceOptions): Workspace<SandboxSDKMastraFilesystem, SandboxSDKMastraSandbox>;
-/** Mastra WorkspaceSandbox implementation for Sandbox SDK providers. */
-declare class SandboxSDKMastraSandbox extends MastraSandbox {
-  readonly id: string;
-  readonly name: string;
-  readonly provider: string;
-  readonly cwd: string;
-  readonly processes: SandboxSDKProcessManager;
-  status: ProviderStatus;
-  private readonly managed;
-  private readonly identity?;
-  private readonly env;
-  private readonly ports;
-  private readonly instructions?;
-  private readonly onFirstCreate?;
-  private readonly createdAt;
-  private session?;
-  constructor(options: CreateMastraSandboxOptions);
-  /** The live normalized Sandbox SDK session. */
-  get sandboxSdk(): Sandbox;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  destroy(): Promise<void>;
-  getPortUrl(port: number, protocol?: "http" | "https" | "ws"): Promise<string>;
-  getInfo(): SandboxInfo;
-  getInstructions(options?: {
-    requestContext?: RequestContext;
-  }): string;
-  /** @deprecated Use `status === "running"` instead. */
-  isReady(): boolean;
-  private killTrackedProcesses;
-}
-/** Mastra background-process bridge for normalized Sandbox SDK processes. */
-declare class SandboxSDKProcessManager extends SandboxProcessManager<SandboxSDKMastraSandbox> {
-  spawn(command: string, options?: SpawnProcessOptions): Promise<ProcessHandle>;
-  list(): Promise<ProcessInfo[]>;
-}
-/** Mastra WorkspaceFilesystem implementation sharing a Mastra sandbox session. */
-declare class SandboxSDKMastraFilesystem extends MastraFilesystem {
-  readonly id: string;
-  readonly name = "Sandbox SDK Filesystem";
-  readonly provider = "sandbox-sdk";
-  readonly readOnly: boolean;
-  readonly basePath: string;
-  status: ProviderStatus;
-  private readonly sandbox;
-  private readonly instructions?;
-  constructor(options: CreateMastraFilesystemOptions);
-  init(): Promise<void>;
-  destroy(): Promise<void>;
-  getInfo(): FilesystemInfo;
-  getInstructions(options?: {
-    requestContext?: RequestContext;
-  }): string;
-  realpath(path: string): Promise<string>;
-  readFile(path: string, options?: ReadOptions): Promise<string | Buffer>;
-  writeFile(path: string, content: FileContent, options?: WriteOptions): Promise<void>;
-  appendFile(path: string, content: FileContent): Promise<void>;
-  deleteFile(path: string, options?: RemoveOptions): Promise<void>;
-  copyFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
-  moveFile(src: string, dest: string, options?: CopyOptions): Promise<void>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-  }): Promise<void>;
-  rmdir(path: string, options?: RemoveOptions): Promise<void>;
-  readdir(path: string, options?: ListOptions): Promise<FileEntry[]>;
-  exists(path: string): Promise<boolean>;
-  stat(path: string): Promise<{
-    name: string;
-    path: string;
-    type: "directory" | "file";
-    size: number;
-    createdAt: Date;
-    modifiedAt: Date;
-  }>;
-  private ready;
-  private assertWritable;
-  private ensureParent;
-  private requireParent;
-  private listDirectory;
-  private findEntry;
-  private nativeStat;
-}
-//#endregion
-export { CreateMastraFilesystemOptions, CreateMastraSandboxOptions, CreateMastraWorkspaceOptions, SandboxSDKMastraFilesystem, SandboxSDKMastraSandbox, SandboxSDKProcessManager, createMastraSandbox, createMastraWorkspace };
-//# sourceMappingURL=index.d.mts.map