@mastra/e2b 0.0.3 → 0.1.0

package/dist/index.cjs

@@ -5,12 +5,6 @@ var e2b = require('e2b');
 var crypto = require('crypto');
 
 // src/sandbox/index.ts
-
-// src/utils/shell-quote.ts
-function shellQuote(arg) {
-  if (/^[a-zA-Z0-9._\-/@:=]+$/.test(arg)) return arg;
-  return "'" + arg.replace(/'/g, "'\\''") + "'";
-}
 var MOUNTABLE_TEMPLATE_VERSION = "v1";
 function createDefaultMountableTemplate() {
   const aptPackages = ["s3fs", "fuse"];
@@ -177,6 +171,117 @@ async function mountGCS(mountPath, config, ctx) {
     throw new Error(`Failed to mount GCS bucket: ${stderr || stdout || error}`);
   }
 }
+var E2BProcessHandle = class extends workspace.ProcessHandle {
+  pid;
+  _e2bHandle;
+  _sandbox;
+  _startTime;
+  constructor(e2bHandle, sandbox, startTime, options) {
+    super(options);
+    this.pid = e2bHandle.pid;
+    this._e2bHandle = e2bHandle;
+    this._sandbox = sandbox;
+    this._startTime = startTime;
+  }
+  /** Delegates to E2B's handle so exitCode reflects server-side state without needing wait(). */
+  get exitCode() {
+    return this._e2bHandle.exitCode;
+  }
+  async wait() {
+    try {
+      const result = await this._e2bHandle.wait();
+      return {
+        success: result.exitCode === 0,
+        exitCode: result.exitCode,
+        stdout: this.stdout,
+        stderr: this.stderr,
+        executionTimeMs: Date.now() - this._startTime
+      };
+    } catch (error) {
+      const errorObj = error;
+      const exitCode = errorObj.result?.exitCode ?? errorObj.exitCode ?? this.exitCode ?? 1;
+      if (errorObj.result?.stdout) this.emitStdout(errorObj.result.stdout);
+      if (errorObj.result?.stderr) this.emitStderr(errorObj.result.stderr);
+      return {
+        success: false,
+        exitCode,
+        stdout: this.stdout,
+        stderr: this.stderr || (error instanceof Error ? error.message : String(error)),
+        executionTimeMs: Date.now() - this._startTime
+      };
+    }
+  }
+  async kill() {
+    if (this.exitCode !== void 0) return false;
+    return this._e2bHandle.kill();
+  }
+  async sendStdin(data) {
+    if (this.exitCode !== void 0) {
+      throw new Error(`Process ${this.pid} has already exited with code ${this.exitCode}`);
+    }
+    await this._sandbox.commands.sendStdin(this.pid, data);
+  }
+};
+var E2BProcessManager = class extends workspace.SandboxProcessManager {
+  async spawn(command, options = {}) {
+    return this.sandbox.retryOnDead(async () => {
+      const e2b = this.sandbox.e2b;
+      const mergedEnv = { ...this.env, ...options.env };
+      const envs = Object.fromEntries(
+        Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0)
+      );
+      let handle;
+      const e2bHandle = await e2b.commands.run(command, {
+        background: true,
+        stdin: true,
+        cwd: options.cwd,
+        envs,
+        timeoutMs: options.timeout,
+        onStdout: (data) => handle.emitStdout(data),
+        onStderr: (data) => handle.emitStderr(data)
+      });
+      handle = new E2BProcessHandle(e2bHandle, e2b, Date.now(), options);
+      this._tracked.set(handle.pid, handle);
+      return handle;
+    });
+  }
+  /**
+   * List processes by querying E2B's commands API.
+   * E2B manages all state server-side — no local tracking needed.
+   */
+  async list() {
+    const e2b = this.sandbox.e2b;
+    const procs = await e2b.commands.list();
+    return procs.map((proc) => ({
+      pid: proc.pid,
+      command: [proc.cmd, ...proc.args].join(" "),
+      running: true
+      // E2B only lists running processes
+    }));
+  }
+  /**
+   * Get a handle to a process by PID.
+   * Checks base class tracking first, then falls back to commands.connect()
+   * for processes spawned externally or before reconnection.
+   */
+  async get(pid) {
+    const tracked = this._tracked.get(pid);
+    if (tracked) return tracked;
+    const e2b = this.sandbox.e2b;
+    let handle;
+    try {
+      const e2bHandle = await e2b.commands.connect(pid, {
+        onStdout: (data) => handle.emitStdout(data),
+        onStderr: (data) => handle.emitStderr(data)
+      });
+      handle = new E2BProcessHandle(e2bHandle, e2b, Date.now());
+      this._tracked.set(pid, handle);
+      return handle;
+    } catch {
+      return void 0;
+    }
+  }
+};
 
 // src/sandbox/index.ts
 var SAFE_MOUNT_PATH = /^\/[a-zA-Z0-9_.\-/]+$/;
@@ -192,7 +297,6 @@ var E2BSandbox = class extends workspace.MastraSandbox {
   id;
   name = "E2BSandbox";
   provider = "e2b";
-  // Status is managed by base class lifecycle methods
   status = "pending";
   _sandbox = null;
   _createdAt = null;
@@ -202,13 +306,17 @@ var E2BSandbox = class extends workspace.MastraSandbox {
   env;
   metadata;
   connectionOpts;
-  // Non-optional (initialized by BaseSandbox)
+  _instructionsOverride;
   /** Resolved template ID after building (if needed) */
   _resolvedTemplateId;
   /** Promise for template preparation (started in constructor) */
   _templatePreparePromise;
   constructor(options = {}) {
-    super({ ...options, name: "E2BSandbox" });
+    super({
+      ...options,
+      name: "E2BSandbox",
+      processes: new E2BProcessManager({ env: options.env ?? {} })
+    });
     this.id = options.id ?? this.generateId();
     this.timeout = options.timeout ?? 3e5;
     this.templateSpec = options.template;
@@ -220,14 +328,12 @@ var E2BSandbox = class extends workspace.MastraSandbox {
       ...options.apiKey && { apiKey: options.apiKey },
       ...options.accessToken && { accessToken: options.accessToken }
     };
+    this._instructionsOverride = options.instructions;
     this._templatePreparePromise = this.resolveTemplate().catch((err) => {
       this.logger.debug(`${LOG_PREFIX} Template preparation error (will retry on start):`, err);
       return "";
     });
   }
-  generateId() {
-    return `e2b-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  }
   /**
    * Get the underlying E2B Sandbox instance for direct access to E2B APIs.
    *
@@ -238,26 +344,168 @@ var E2BSandbox = class extends workspace.MastraSandbox {
    *
    * @example Direct file operations
    * ```typescript
-   * const e2bSandbox = sandbox.instance;
-   * await e2bSandbox.files.write('/tmp/test.txt', 'Hello');
-   * const content = await e2bSandbox.files.read('/tmp/test.txt');
-   * const files = await e2bSandbox.files.list('/tmp');
+   * const e2b = sandbox.e2b;
+   * await e2b.files.write('/tmp/test.txt', 'Hello');
+   * const content = await e2b.files.read('/tmp/test.txt');
+   * const files = await e2b.files.list('/tmp');
    * ```
    *
    * @example Access ports
    * ```typescript
-   * const e2bSandbox = sandbox.instance;
-   * const url = e2bSandbox.getHost(3000);
+   * const e2b = sandbox.e2b;
+   * const url = e2b.getHost(3000);
    * ```
    */
-  get instance() {
+  get e2b() {
     if (!this._sandbox) {
       throw new workspace.SandboxNotReadyError(this.id);
     }
     return this._sandbox;
   }
   // ---------------------------------------------------------------------------
-  // Mount Support
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Start the E2B sandbox.
+   * Handles template preparation, existing sandbox reconnection, and new sandbox creation.
+   *
+   * Status management and mount processing are handled by the base class.
+   */
+  async start() {
+    if (this._sandbox) {
+      return;
+    }
+    const [existingSandbox, templateId] = await Promise.all([
+      this.findExistingSandbox(),
+      this._templatePreparePromise || this.resolveTemplate()
+    ]);
+    if (existingSandbox) {
+      this._sandbox = existingSandbox;
+      this._createdAt = /* @__PURE__ */ new Date();
+      this.logger.debug(`${LOG_PREFIX} Reconnected to existing sandbox for: ${this.id}`);
+      const expectedPaths = Array.from(this.mounts.entries.keys());
+      this.logger.debug(`${LOG_PREFIX} Running mount reconciliation...`);
+      await this.reconcileMounts(expectedPaths);
+      this.logger.debug(`${LOG_PREFIX} Mount reconciliation complete`);
+      return;
+    }
+    let resolvedTemplateId = templateId;
+    if (!resolvedTemplateId) {
+      this.logger.debug(`${LOG_PREFIX} Template preparation failed earlier, retrying...`);
+      resolvedTemplateId = await this.resolveTemplate();
+    }
+    this.logger.debug(`${LOG_PREFIX} Creating new sandbox for: ${this.id} with template: ${resolvedTemplateId}`);
+    try {
+      this._sandbox = await e2b.Sandbox.betaCreate(resolvedTemplateId, {
+        ...this.connectionOpts,
+        autoPause: true,
+        metadata: {
+          ...this.metadata,
+          "mastra-sandbox-id": this.id
+        },
+        timeoutMs: this.timeout
+      });
+    } catch (createError) {
+      const errorStr = String(createError);
+      if (errorStr.includes("404") && errorStr.includes("not found") && !this.templateSpec) {
+        this.logger.debug(`${LOG_PREFIX} Template not found, rebuilding: ${templateId}`);
+        this._resolvedTemplateId = void 0;
+        const rebuiltTemplateId = await this.buildDefaultTemplate();
+        this.logger.debug(`${LOG_PREFIX} Retrying sandbox creation with rebuilt template: ${rebuiltTemplateId}`);
+        this._sandbox = await e2b.Sandbox.betaCreate(rebuiltTemplateId, {
+          ...this.connectionOpts,
+          autoPause: true,
+          metadata: {
+            ...this.metadata,
+            "mastra-sandbox-id": this.id
+          },
+          timeoutMs: this.timeout
+        });
+      } else {
+        throw createError;
+      }
+    }
+    this.logger.debug(`${LOG_PREFIX} Created sandbox ${this._sandbox.sandboxId} for logical ID: ${this.id}`);
+    this._createdAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Stop the E2B sandbox.
+   * Unmounts all filesystems and releases the sandbox reference.
+   * Status management is handled by the base class.
+   */
+  async stop() {
+    try {
+      const procs = await this.processes.list();
+      await Promise.all(procs.map((p) => this.processes.kill(p.pid)));
+    } catch {
+    }
+    for (const mountPath of [...this.mounts.entries.keys()]) {
+      try {
+        await this.unmount(mountPath);
+      } catch {
+      }
+    }
+    this._sandbox = null;
+  }
+  /**
+   * Destroy the E2B sandbox and clean up all resources.
+   * Unmounts filesystems, kills the sandbox, and clears mount state.
+   * Status management is handled by the base class.
+   */
+  async destroy() {
+    if (this._sandbox) {
+      try {
+        const procs = await this.processes.list();
+        await Promise.all(procs.map((p) => this.processes.kill(p.pid)));
+      } catch {
+      }
+      for (const mountPath of [...this.mounts.entries.keys()]) {
+        try {
+          await this.unmount(mountPath);
+        } catch {
+        }
+      }
+      try {
+        await this._sandbox.kill();
+      } catch {
+      }
+      this._sandbox = null;
+    }
+    this.mounts.clear();
+  }
+  async getInfo() {
+    return {
+      id: this.id,
+      name: this.name,
+      provider: this.provider,
+      status: this.status,
+      createdAt: this._createdAt ?? /* @__PURE__ */ new Date(),
+      mounts: Array.from(this.mounts.entries).map(([path, entry]) => ({
+        path,
+        filesystem: entry.filesystem?.provider ?? entry.config?.type ?? "unknown"
+      })),
+      metadata: {
+        ...this.metadata
+      }
+    };
+  }
+  /**
+   * Get instructions describing this E2B sandbox.
+   * Used by agents to understand the execution environment.
+   */
+  getInstructions(opts) {
+    if (this._instructionsOverride === void 0) return this._getDefaultInstructions();
+    if (typeof this._instructionsOverride === "string") return this._instructionsOverride;
+    const defaultInstructions = this._getDefaultInstructions();
+    return this._instructionsOverride({ defaultInstructions, requestContext: opts?.requestContext });
+  }
+  _getDefaultInstructions() {
+    const mountCount = this.mounts.entries.size;
+    const mountInfo = mountCount > 0 ? ` ${mountCount} filesystem(s) mounted via FUSE.` : "";
+    return `Cloud sandbox with /home/user as working directory.${mountInfo}`;
+  }
+  // ---------------------------------------------------------------------------
+  // Mounting
   // ---------------------------------------------------------------------------
   /**
    * Mount a filesystem at a path in the sandbox.
@@ -359,23 +607,6 @@ var E2BSandbox = class extends workspace.MastraSandbox {
     this.logger.debug(`${LOG_PREFIX} Mounted ${mountPath}`);
     return { success: true, mountPath };
   }
-  /**
-   * Write marker file for detecting config changes on reconnect.
-   * Stores both the mount path and config hash in the file.
-   */
-  async writeMarkerFile(mountPath) {
-    if (!this._sandbox) return;
-    const markerContent = this.mounts.getMarkerContent(mountPath);
-    if (!markerContent) return;
-    const filename = this.mounts.markerFilename(mountPath);
-    const markerPath = `/tmp/.mastra-mounts/${filename}`;
-    try {
-      await this._sandbox.commands.run("mkdir -p /tmp/.mastra-mounts");
-      await this._sandbox.files.write(markerPath, markerContent);
-    } catch {
-      this.logger.debug(`${LOG_PREFIX} Warning: Could not write marker file at ${markerPath}`);
-    }
-  }
   /**
    * Unmount a filesystem from a path in the sandbox.
    */
@@ -470,116 +701,49 @@ var E2BSandbox = class extends workspace.MastraSandbox {
       this.logger.debug(`${LOG_PREFIX} Error during orphan cleanup (non-fatal)`);
     }
   }
-  /**
-   * Check if a path is already mounted and if the config matches.
-   *
-   * @param mountPath - The mount path to check
-   * @param newConfig - The new config to compare against the stored config
-   * @returns 'not_mounted' | 'matching' | 'mismatched'
-   */
-  async checkExistingMount(mountPath, newConfig) {
-    if (!this._sandbox) throw new workspace.SandboxNotReadyError(this.id);
-    const mountCheck = await this._sandbox.commands.run(
-      `mountpoint -q "${mountPath}" && echo "mounted" || echo "not mounted"`
-    );
-    if (mountCheck.stdout.trim() !== "mounted") {
-      return "not_mounted";
-    }
-    const filename = this.mounts.markerFilename(mountPath);
-    const markerPath = `/tmp/.mastra-mounts/${filename}`;
-    try {
-      const markerResult = await this._sandbox.commands.run(`cat "${markerPath}" 2>/dev/null || echo ""`);
-      const parsed = this.mounts.parseMarkerContent(markerResult.stdout.trim());
-      if (!parsed) {
-        return "mismatched";
-      }
-      const newConfigHash = this.mounts.computeConfigHash(newConfig);
-      this.logger.debug(
-        `${LOG_PREFIX} Marker check - stored hash: "${parsed.configHash}", new config hash: "${newConfigHash}"`
-      );
-      if (parsed.path === mountPath && parsed.configHash === newConfigHash) {
-        return "matching";
-      }
-    } catch {
-    }
-    return "mismatched";
+  // ---------------------------------------------------------------------------
+  // Deprecated
+  // ---------------------------------------------------------------------------
+  /** @deprecated Use `e2b` instead. */
+  get instance() {
+    return this.e2b;
+  }
+  /** @deprecated Use `status === 'running'` instead. */
+  async isReady() {
+    return this.status === "running" && this._sandbox !== null;
   }
   // ---------------------------------------------------------------------------
-  // Lifecycle (overrides base class protected methods)
+  // Internal Helpers
   // ---------------------------------------------------------------------------
+  generateId() {
+    return `e2b-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  }
   /**
-   * Start the E2B sandbox.
-   * Handles template preparation, existing sandbox reconnection, and new sandbox creation.
-   *
-   * Status management and mount processing are handled by the base class.
+   * Find an existing sandbox with matching mastra-sandbox-id metadata.
+   * Returns the connected sandbox if found, null otherwise.
    */
-  async start() {
-    if (this._sandbox) {
-      return;
-    }
-    const [existingSandbox, templateId] = await Promise.all([
-      this.findExistingSandbox(),
-      this._templatePreparePromise || this.resolveTemplate()
-    ]);
-    if (existingSandbox) {
-      this._sandbox = existingSandbox;
-      this._createdAt = /* @__PURE__ */ new Date();
-      this.logger.debug(`${LOG_PREFIX} Reconnected to existing sandbox for: ${this.id}`);
-      const expectedPaths = Array.from(this.mounts.entries.keys());
-      this.logger.debug(`${LOG_PREFIX} Running mount reconciliation...`);
-      await this.reconcileMounts(expectedPaths);
-      this.logger.debug(`${LOG_PREFIX} Mount reconciliation complete`);
-      return;
-    }
-    let resolvedTemplateId = templateId;
-    if (!resolvedTemplateId) {
-      this.logger.debug(`${LOG_PREFIX} Template preparation failed earlier, retrying...`);
-      resolvedTemplateId = await this.resolveTemplate();
-    }
-    this.logger.debug(`${LOG_PREFIX} Creating new sandbox for: ${this.id} with template: ${resolvedTemplateId}`);
+  async findExistingSandbox() {
     try {
-      this._sandbox = await e2b.Sandbox.betaCreate(resolvedTemplateId, {
+      const paginator = e2b.Sandbox.list({
         ...this.connectionOpts,
-        autoPause: true,
-        metadata: {
-          ...this.metadata,
-          "mastra-sandbox-id": this.id
-        },
-        timeoutMs: this.timeout
+        query: {
+          metadata: { "mastra-sandbox-id": this.id },
+          state: ["running", "paused"]
+        }
       });
-    } catch (createError) {
-      const errorStr = String(createError);
-      if (errorStr.includes("404") && errorStr.includes("not found") && !this.templateSpec) {
-        this.logger.debug(`${LOG_PREFIX} Template not found, rebuilding: ${templateId}`);
-        this._resolvedTemplateId = void 0;
-        const rebuiltTemplateId = await this.buildDefaultTemplate();
-        this.logger.debug(`${LOG_PREFIX} Retrying sandbox creation with rebuilt template: ${rebuiltTemplateId}`);
-        this._sandbox = await e2b.Sandbox.betaCreate(rebuiltTemplateId, {
-          ...this.connectionOpts,
-          autoPause: true,
-          metadata: {
-            ...this.metadata,
-            "mastra-sandbox-id": this.id
-          },
-          timeoutMs: this.timeout
-        });
-      } else {
-        throw createError;
+      const sandboxes = await paginator.nextItems();
+      this.logger.debug(`${LOG_PREFIX} sandboxes:`, sandboxes);
+      if (sandboxes.length > 0) {
+        const existingSandbox = sandboxes[0];
+        this.logger.debug(
+          `${LOG_PREFIX} Found existing sandbox for ${this.id}: ${existingSandbox.sandboxId} (state: ${existingSandbox.state})`
+        );
+        return await e2b.Sandbox.connect(existingSandbox.sandboxId, this.connectionOpts);
       }
+    } catch (e) {
+      this.logger.debug(`${LOG_PREFIX} Error querying for existing sandbox:`, e);
     }
-    this.logger.debug(`${LOG_PREFIX} Created sandbox ${this._sandbox.sandboxId} for logical ID: ${this.id}`);
-    this._createdAt = /* @__PURE__ */ new Date();
-  }
-  /**
-   * Build the default mountable template (bypasses exists check).
-   */
-  async buildDefaultTemplate() {
-    const { template, id } = createDefaultMountableTemplate();
-    this.logger.debug(`${LOG_PREFIX} Building default mountable template: ${id}...`);
-    const buildResult = await e2b.Template.build(template, id, this.connectionOpts);
-    this._resolvedTemplateId = buildResult.templateId;
-    this.logger.debug(`${LOG_PREFIX} Template built: ${buildResult.templateId}`);
-    return buildResult.templateId;
+    return null;
   }
   /**
    * Resolve the template specification to a template ID.
@@ -628,112 +792,62 @@ var E2BSandbox = class extends workspace.MastraSandbox {
     return buildResult.templateId;
   }
   /**
-   * Find an existing sandbox with matching mastra-sandbox-id metadata.
-   * Returns the connected sandbox if found, null otherwise.
+   * Build the default mountable template (bypasses exists check).
    */
-  async findExistingSandbox() {
-    try {
-      const paginator = e2b.Sandbox.list({
-        ...this.connectionOpts,
-        query: {
-          metadata: { "mastra-sandbox-id": this.id },
-          state: ["running", "paused"]
-        }
-      });
-      const sandboxes = await paginator.nextItems();
-      this.logger.debug(`${LOG_PREFIX} sandboxes:`, sandboxes);
-      if (sandboxes.length > 0) {
-        const existingSandbox = sandboxes[0];
-        this.logger.debug(
-          `${LOG_PREFIX} Found existing sandbox for ${this.id}: ${existingSandbox.sandboxId} (state: ${existingSandbox.state})`
-        );
-        return await e2b.Sandbox.connect(existingSandbox.sandboxId, this.connectionOpts);
-      }
-    } catch (e) {
-      this.logger.debug(`${LOG_PREFIX} Error querying for existing sandbox:`, e);
-    }
-    return null;
+  async buildDefaultTemplate() {
+    const { template, id } = createDefaultMountableTemplate();
+    this.logger.debug(`${LOG_PREFIX} Building default mountable template: ${id}...`);
+    const buildResult = await e2b.Template.build(template, id, this.connectionOpts);
+    this._resolvedTemplateId = buildResult.templateId;
+    this.logger.debug(`${LOG_PREFIX} Template built: ${buildResult.templateId}`);
+    return buildResult.templateId;
   }
   /**
-   * Stop the E2B sandbox.
-   * Unmounts all filesystems and releases the sandbox reference.
-   * Status management is handled by the base class.
+   * Write marker file for detecting config changes on reconnect.
+   * Stores both the mount path and config hash in the file.
    */
-  async stop() {
-    for (const mountPath of [...this.mounts.entries.keys()]) {
-      try {
-        await this.unmount(mountPath);
-      } catch {
-      }
+  async writeMarkerFile(mountPath) {
+    if (!this._sandbox) return;
+    const markerContent = this.mounts.getMarkerContent(mountPath);
+    if (!markerContent) return;
+    const filename = this.mounts.markerFilename(mountPath);
+    const markerPath = `/tmp/.mastra-mounts/${filename}`;
+    try {
+      await this._sandbox.commands.run("mkdir -p /tmp/.mastra-mounts");
+      await this._sandbox.files.write(markerPath, markerContent);
+    } catch {
+      this.logger.debug(`${LOG_PREFIX} Warning: Could not write marker file at ${markerPath}`);
     }
-    this._sandbox = null;
   }
   /**
-   * Destroy the E2B sandbox and clean up all resources.
-   * Unmounts filesystems, kills the sandbox, and clears mount state.
-   * Status management is handled by the base class.
+   * Check if a path is already mounted and if the config matches.
    */
-  async destroy() {
-    for (const mountPath of [...this.mounts.entries.keys()]) {
-      try {
-        await this.unmount(mountPath);
-      } catch {
-      }
+  async checkExistingMount(mountPath, newConfig) {
+    if (!this._sandbox) throw new workspace.SandboxNotReadyError(this.id);
+    const mountCheck = await this._sandbox.commands.run(
+      `mountpoint -q "${mountPath}" && echo "mounted" || echo "not mounted"`
+    );
+    if (mountCheck.stdout.trim() !== "mounted") {
+      return "not_mounted";
     }
-    if (this._sandbox) {
-      try {
-        await this._sandbox.kill();
-      } catch {
+    const filename = this.mounts.markerFilename(mountPath);
+    const markerPath = `/tmp/.mastra-mounts/${filename}`;
+    try {
+      const markerResult = await this._sandbox.commands.run(`cat "${markerPath}" 2>/dev/null || echo ""`);
+      const parsed = this.mounts.parseMarkerContent(markerResult.stdout.trim());
+      if (!parsed) {
+        return "mismatched";
       }
-    }
-    this._sandbox = null;
-    this.mounts.clear();
-  }
-  /**
-   * Check if the sandbox is ready for operations.
-   */
-  async isReady() {
-    return this.status === "running" && this._sandbox !== null;
-  }
-  /**
-   * Get information about the current state of the sandbox.
-   */
-  async getInfo() {
-    return {
-      id: this.id,
-      name: this.name,
-      provider: this.provider,
-      status: this.status,
-      createdAt: this._createdAt ?? /* @__PURE__ */ new Date(),
-      mounts: Array.from(this.mounts.entries).map(([path, entry]) => ({
-        path,
-        filesystem: entry.filesystem?.provider ?? entry.config?.type ?? "unknown"
-      })),
-      metadata: {
-        ...this.metadata
+      const newConfigHash = this.mounts.computeConfigHash(newConfig);
+      this.logger.debug(
+        `${LOG_PREFIX} Marker check - stored hash: "${parsed.configHash}", new config hash: "${newConfigHash}"`
+      );
+      if (parsed.path === mountPath && parsed.configHash === newConfigHash) {
+        return "matching";
       }
-    };
-  }
-  /**
-   * Get instructions describing this E2B sandbox.
-   * Used by agents to understand the execution environment.
-   */
-  getInstructions() {
-    const mountCount = this.mounts.entries.size;
-    const mountInfo = mountCount > 0 ? ` ${mountCount} filesystem(s) mounted via FUSE.` : "";
-    return `Cloud sandbox with /home/user as working directory.${mountInfo}`;
-  }
-  // ---------------------------------------------------------------------------
-  // Internal Helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * Ensure the sandbox is started and return the E2B Sandbox instance.
-   * Uses base class ensureRunning() for status management and error handling.
-   * @throws {SandboxNotReadyError} if sandbox fails to start
-   */
-  async ensureSandbox() {
-    await this.ensureRunning();
-    return this._sandbox;
+    } catch {
+    }
+    return "mismatched";
   }
   /**
    * Check if an error indicates the sandbox itself is dead/gone.
@@ -761,76 +875,29 @@ var E2BSandbox = class extends workspace.MastraSandbox {
     }
     this.status = "stopped";
   }
-  // ---------------------------------------------------------------------------
-  // Command Execution
-  // ---------------------------------------------------------------------------
   /**
-   * Execute a shell command in the sandbox.
-   * Automatically starts the sandbox if not already running.
-   * Retries once if the sandbox is found to be dead.
+   * Execute an operation with automatic retry if the sandbox is found to be dead.
+   *
+   * When the E2B sandbox times out or crashes mid-operation, this method
+   * resets sandbox state, restarts it, and retries the operation once.
+   *
+   * @internal Used by E2BProcessManager to handle dead sandboxes during spawn.
    */
-  async executeCommand(command, args = [], options = {}) {
-    this.logger.debug(`${LOG_PREFIX} Executing: ${command} ${args.join(" ")}`, options);
-    const sandbox = await this.ensureSandbox();
-    const startTime = Date.now();
-    const fullCommand = args.length > 0 ? `${command} ${args.map(shellQuote).join(" ")}` : command;
-    this.logger.debug(`${LOG_PREFIX} Executing: ${fullCommand}`);
+  async retryOnDead(fn) {
     try {
-      const mergedEnv = { ...this.env, ...options.env };
-      const envs = Object.fromEntries(
-        Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0)
-      );
-      const result = await sandbox.commands.run(fullCommand, {
-        cwd: options.cwd,
-        envs,
-        timeoutMs: options.timeout,
-        onStdout: options.onStdout,
-        onStderr: options.onStderr
-      });
-      const executionTimeMs = Date.now() - startTime;
-      this.logger.debug(`${LOG_PREFIX} Exit code: ${result.exitCode} (${executionTimeMs}ms)`);
-      if (result.stdout) this.logger.debug(`${LOG_PREFIX} stdout:
-${result.stdout}`);
-      if (result.stderr) this.logger.debug(`${LOG_PREFIX} stderr:
-${result.stderr}`);
-      return {
-        success: result.exitCode === 0,
-        exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr,
-        executionTimeMs,
-        command,
-        args
-      };
+      return await fn();
     } catch (error) {
       if (this.isSandboxDeadError(error) && !this._isRetrying) {
         this.handleSandboxTimeout();
         this._isRetrying = true;
         try {
-          return await this.executeCommand(command, args, options);
+          await this.ensureRunning();
+          return await fn();
         } finally {
           this._isRetrying = false;
         }
       }
-      const executionTimeMs = Date.now() - startTime;
-      const errorObj = error;
-      const stdout = errorObj.result?.stdout || "";
-      const stderr = errorObj.result?.stderr || (error instanceof Error ? error.message : String(error));
-      const exitCode = errorObj.result?.exitCode ?? 1;
-      this.logger.debug(`${LOG_PREFIX} Exit code: ${exitCode} (${executionTimeMs}ms) [error]`);
-      if (stdout) this.logger.debug(`${LOG_PREFIX} stdout:
-${stdout}`);
-      if (stderr) this.logger.debug(`${LOG_PREFIX} stderr:
-${stderr}`);
-      return {
-        success: false,
-        exitCode,
-        stdout,
-        stderr,
-        executionTimeMs,
-        command,
-        args
-      };
+      throw error;
     }
   }
 };
@@ -864,6 +931,7 @@ var e2bSandboxProvider = {
   createSandbox: (config) => new E2BSandbox(config)
 };
 
+exports.E2BProcessManager = E2BProcessManager;
 exports.E2BSandbox = E2BSandbox;
 exports.createDefaultMountableTemplate = createDefaultMountableTemplate;
 exports.e2bSandboxProvider = e2bSandboxProvider;