@opencoredev/sandbox-sdk 0.1.0

package/dist/eve/index.mjs

@@ -0,0 +1,155 @@
+import { n as isSandboxError, t as SandboxError } from "../errors-Ch9PHKTd.mjs";
+import { r as toAISandboxSession } from "../ai-DhfwIZdL.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

@@ -0,0 +1 @@
+{"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-B1YT6OQ8.d.mts

@@ -0,0 +1,25 @@
+import { o as SandboxProvider } from "./provider-_caCV8kk.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-B1YT6OQ8.d.mts.map

package/dist/index-BMFkO6Fv.d.mts

@@ -0,0 +1,31 @@
+import { f as Sandbox, r as CapabilityMode, t as Capability } from "./types-BTagTtsp.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-BMFkO6Fv.d.mts.map

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+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-BTagTtsp.mjs";
+import { a as SandboxNetworkPolicy, i as ManagedSandboxSession, n as ManagedSandboxProvider, r as ManagedSandboxResumeOptions, t as ManagedSandboxCreateOptions } from "./provider-_caCV8kk.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-BMFkO6Fv.mjs";
+import { n as createSandbox, r as withSandbox } from "./sandbox-BUYT-1C9.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

@@ -0,0 +1,38 @@
+import { a as sandboxErrorCodes, i as redactSensitive, n as isSandboxError, t as SandboxError } from "./errors-Ch9PHKTd.mjs";
+import { i as supports, r as requireCapability, t as capabilityMode } from "./capabilities-COKpwoFH.mjs";
+import { n as withSandbox, t as createSandbox } from "./sandbox-BwyHcB_C.mjs";
+
+//#region src/core/types.ts
+const providerNames = [
+	"local",
+	"e2b",
+	"daytona",
+	"vercel",
+	"upstash"
+];
+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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/core/types.ts"],"sourcesContent":["export const providerNames = [\"local\", \"e2b\", \"daytona\", \"vercel\", \"upstash\"] 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  stop(): Promise<void>;\n}\n"],"mappings":";;;;;AAAA,MAAa,gBAAgB;CAAC;CAAS;CAAO;CAAW;CAAU;CAAU;AAG7E,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/mastra/index.d.mts

@@ -0,0 +1,118 @@
+import { f as Sandbox } from "../types-BTagTtsp.mjs";
+import { o as SandboxProvider } from "../provider-_caCV8kk.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