@mastra/docker 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -1,857 +1,885 @@
-'use strict';
-
-var util = require('util');
-var workspace = require('@mastra/core/workspace');
-var Docker = require('dockerode');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Docker__default = /*#__PURE__*/_interopDefault(Docker);
-
-// src/sandbox/index.ts
-var DockerProcessHandle = class extends workspace.ProcessHandle {
-  pid;
-  _exec;
-  _container;
-  _startTime;
-  _exitCode;
-  /** @internal Set by kill() and timeout to distinguish forced termination from natural exit */
-  _killed = false;
-  /** @internal Set by the timeout path to distinguish timeout kills from explicit kills */
-  _timedOut = false;
-  _waitPromise = null;
-  _stdinStream = null;
-  _execStream = null;
-  constructor(exec, container, startTime, stdinStream, options) {
-    super(options);
-    this.pid = exec.id;
-    this._exec = exec;
-    this._container = container;
-    this._startTime = startTime;
-    this._stdinStream = stdinStream;
-  }
-  get exitCode() {
-    return this._exitCode;
-  }
-  /** @internal Set exit code when stream closes */
-  _setExitCode(code) {
-    this._exitCode = code;
-  }
-  /** @internal Set the wait promise from spawn */
-  _setWaitPromise(p) {
-    this._waitPromise = p;
-  }
-  /** @internal Set the exec stream so kill() can destroy it */
-  _setExecStream(stream) {
-    this._execStream = stream;
-  }
-  async wait() {
-    if (this._waitPromise) {
-      return this._waitPromise;
-    }
-    const info = await this._inspectExec();
-    return {
-      success: (info.ExitCode ?? 1) === 0,
-      exitCode: info.ExitCode ?? 1,
-      stdout: this.stdout,
-      stderr: this.stderr,
-      executionTimeMs: Date.now() - this._startTime
-    };
-  }
-  async kill() {
-    if (this._exitCode !== void 0) return false;
-    try {
-      let info = await this._inspectExec();
-      if (!info.Running || !info.Pid) {
-        await new Promise((r) => setTimeout(r, 50));
-        info = await this._inspectExec();
-      }
-      if (!info.Running) {
-        this._killed = true;
-        this._destroyStream();
-        return false;
-      }
-      const pid = info.Pid;
-      if (!pid) {
-        this._killed = true;
-        this._destroyStream();
-        return false;
-      }
-      const killExec = await this._container.exec({
-        Cmd: ["sh", "-c", `kill -9 -${pid} 2>/dev/null || kill -9 ${pid}`],
-        AttachStdout: false,
-        AttachStderr: false
-      });
-      await killExec.start({});
-      this._killed = true;
-      this._destroyStream();
-      return true;
-    } catch (error) {
-      this._killed = true;
-      this._destroyStream();
-      const msg = error instanceof Error ? error.message.toLowerCase() : "";
-      if (!msg.includes("no such process") && !msg.includes("esrch")) {
-        console.warn(`[DockerProcessManager] kill(${this.pid}) failed unexpectedly:`, error);
-      }
-      return false;
-    }
-  }
-  async sendStdin(data) {
-    if (this._exitCode !== void 0) {
-      throw new Error(`Process ${this.pid} has already exited with code ${this._exitCode}`);
-    }
-    if (!this._stdinStream) {
-      throw new Error(`Process ${this.pid} was not started with stdin support`);
-    }
-    this._stdinStream.write(data);
-  }
-  /** @internal Force-close the exec stream to unblock wait(). */
-  _destroyStream() {
-    const stream = this._execStream;
-    if (stream && typeof stream.destroy === "function") {
-      stream.destroy();
-      this._execStream = null;
-    }
-  }
-  async _inspectExec() {
-    return this._exec.inspect();
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var DockerProcessManager = class extends workspace.SandboxProcessManager {
-  _container = null;
-  _defaultTimeout;
-  constructor(options) {
-    super(options);
-    this._defaultTimeout = options.defaultTimeout ?? 0;
-  }
-  /** @internal Called by DockerSandbox after container is ready */
-  setContainer(container) {
-    this._container = container;
-  }
-  /** Get the container, throwing if not set */
-  get container() {
-    if (!this._container) {
-      throw new Error("Docker container not available. Has the sandbox been started?");
-    }
-    return this._container;
-  }
-  async spawn(command, options = {}) {
-    const container = this.container;
-    const mergedEnv = { ...this.env, ...options.env };
-    const envArray = Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0).map(([k, v]) => `${k}=${v}`);
-    const exec = await container.exec({
-      Cmd: ["sh", "-c", command],
-      AttachStdout: true,
-      AttachStderr: true,
-      AttachStdin: true,
-      Tty: false,
-      Env: envArray.length > 0 ? envArray : void 0,
-      WorkingDir: options.cwd
-    });
-    const stream = await exec.start({ hijack: true, stdin: true });
-    const startTime = Date.now();
-    const handle = new DockerProcessHandle(exec, container, startTime, stream, options);
-    handle._setExecStream(stream);
-    const waitPromise = new Promise((resolve) => {
-      const buffer = [];
-      stream.on("data", (chunk) => {
-        buffer.push(chunk);
-        let combined = Buffer.concat(buffer);
-        buffer.length = 0;
-        while (combined.length >= 8) {
-          const type = combined[0];
-          const size = combined.readUInt32BE(4);
-          if (combined.length < 8 + size) {
-            buffer.push(combined);
-            break;
-          }
-          const payload = combined.subarray(8, 8 + size).toString("utf-8");
-          if (type === 1) {
-            handle.emitStdout(payload);
-          } else if (type === 2) {
-            handle.emitStderr(payload);
-          }
-          combined = combined.subarray(8 + size);
-        }
-        if (combined.length > 0 && buffer.length === 0) {
-          buffer.push(combined);
-        }
-      });
-      stream.on("end", async () => {
-        try {
-          const info = await exec.inspect();
-          const exitCode = info.ExitCode ?? 1;
-          handle._setExitCode(exitCode);
-          resolve({
-            success: exitCode === 0,
-            exitCode,
-            stdout: handle.stdout,
-            stderr: handle.stderr,
-            executionTimeMs: Date.now() - startTime
-          });
-        } catch {
-          handle._setExitCode(1);
-          resolve({
-            success: false,
-            exitCode: 1,
-            stdout: handle.stdout,
-            stderr: handle.stderr,
-            executionTimeMs: Date.now() - startTime
-          });
-        }
-      });
-      stream.on("close", () => {
-        if (handle.exitCode !== void 0) return;
-        if (!handle._killed) return;
-        handle._setExitCode(137);
-        resolve({
-          success: false,
-          exitCode: 137,
-          stdout: handle.stdout,
-          stderr: handle.stderr,
-          executionTimeMs: Date.now() - startTime,
-          killed: true,
-          timedOut: handle._timedOut
-        });
-      });
-      stream.on("error", () => {
-        if (handle.exitCode !== void 0) return;
-        handle._setExitCode(1);
-        resolve({
-          success: false,
-          exitCode: 1,
-          stdout: handle.stdout,
-          stderr: handle.stderr || "Stream error",
-          executionTimeMs: Date.now() - startTime
-        });
-      });
-    });
-    const resolvedTimeout = options.timeout ?? this._defaultTimeout;
-    if (resolvedTimeout > 0) {
-      const timeoutMs = resolvedTimeout;
-      const timer = setTimeout(() => {
-        if (handle.exitCode === void 0) {
-          handle._killed = true;
-          handle._timedOut = true;
-          handle.kill().catch(() => {
-          });
-          handle._destroyStream();
-        }
-      }, timeoutMs);
-      void waitPromise.then(() => clearTimeout(timer));
-    }
-    handle._setWaitPromise(waitPromise);
-    this._tracked.set(handle.pid, handle);
-    return handle;
-  }
-  /** Clear all tracked process handles and release the container reference (e.g., after container stop/destroy) */
-  reset() {
-    this._tracked.clear();
-    this._container = null;
-  }
-  async list() {
-    const results = [];
-    for (const [pid, handle] of this._tracked) {
-      results.push({
-        pid,
-        command: handle.command,
-        running: handle.exitCode === void 0,
-        exitCode: handle.exitCode
-      });
-    }
-    return results;
-  }
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let util = require("util");
+let _mastra_core_workspace = require("@mastra/core/workspace");
+let dockerode = require("dockerode");
+dockerode = __toESM(dockerode, 1);
+//#region src/sandbox/process-manager.ts
+/**
+* Wraps a Docker exec instance to conform to Mastra's ProcessHandle.
+* Not exported — internal to this module.
+*
+* Listener dispatch is handled by the base class. The manager's spawn()
+* method wires Docker stream callbacks to handle.emitStdout/emitStderr.
+*/
+var DockerProcessHandle = class extends _mastra_core_workspace.ProcessHandle {
+	pid;
+	_exec;
+	_container;
+	_startTime;
+	_exitCode;
+	/** @internal Set by kill() and timeout to distinguish forced termination from natural exit */
+	_killed = false;
+	/** @internal Set by the timeout path to distinguish timeout kills from explicit kills */
+	_timedOut = false;
+	_waitPromise = null;
+	_stdinStream = null;
+	_execStream = null;
+	constructor(exec, container, startTime, stdinStream, options) {
+		super(options);
+		this.pid = exec.id;
+		this._exec = exec;
+		this._container = container;
+		this._startTime = startTime;
+		this._stdinStream = stdinStream;
+	}
+	get exitCode() {
+		return this._exitCode;
+	}
+	/** @internal Set exit code when stream closes */
+	_setExitCode(code) {
+		this._exitCode = code;
+	}
+	/** @internal Set the wait promise from spawn */
+	_setWaitPromise(p) {
+		this._waitPromise = p;
+	}
+	/** @internal Set the exec stream so kill() can destroy it */
+	_setExecStream(stream) {
+		this._execStream = stream;
+	}
+	async wait() {
+		if (this._waitPromise) return this._waitPromise;
+		const info = await this._inspectExec();
+		return {
+			success: (info.ExitCode ?? 1) === 0,
+			exitCode: info.ExitCode ?? 1,
+			stdout: this.stdout,
+			stderr: this.stderr,
+			executionTimeMs: Date.now() - this._startTime
+		};
+	}
+	async kill() {
+		if (this._exitCode !== void 0) return false;
+		try {
+			let info = await this._inspectExec();
+			if (!info.Running || !info.Pid) {
+				await new Promise((r) => setTimeout(r, 50));
+				info = await this._inspectExec();
+			}
+			if (!info.Running) {
+				this._killed = true;
+				this._destroyStream();
+				return false;
+			}
+			const pid = info.Pid;
+			if (!pid) {
+				this._killed = true;
+				this._destroyStream();
+				return false;
+			}
+			await (await this._container.exec({
+				Cmd: [
+					"sh",
+					"-c",
+					`kill -9 -${pid} 2>/dev/null || kill -9 ${pid}`
+				],
+				AttachStdout: false,
+				AttachStderr: false
+			})).start({});
+			this._killed = true;
+			this._destroyStream();
+			return true;
+		} catch (error) {
+			this._killed = true;
+			this._destroyStream();
+			const msg = error instanceof Error ? error.message.toLowerCase() : "";
+			if (!msg.includes("no such process") && !msg.includes("esrch")) console.warn(`[DockerProcessManager] kill(${this.pid}) failed unexpectedly:`, error);
+			return false;
+		}
+	}
+	async sendStdin(data) {
+		if (this._exitCode !== void 0) throw new Error(`Process ${this.pid} has already exited with code ${this._exitCode}`);
+		if (!this._stdinStream) throw new Error(`Process ${this.pid} was not started with stdin support`);
+		return new Promise((resolve, reject) => {
+			this._stdinStream.write(data, (error) => error ? reject(error) : resolve());
+		});
+	}
+	async closeStdin() {
+		if (this._exitCode !== void 0) throw new Error(`Process ${this.pid} has already exited with code ${this._exitCode}`);
+		if (!this._stdinStream) throw new Error(`Process ${this.pid} was not started with stdin support`);
+		const stream = this._stdinStream;
+		if (stream.writableEnded) return;
+		await new Promise((resolve) => stream.end(resolve));
+	}
+	/** @internal Force-close the exec stream to unblock wait(). */
+	_destroyStream() {
+		const stream = this._execStream;
+		if (stream && typeof stream.destroy === "function") {
+			stream.destroy();
+			this._execStream = null;
+		}
+	}
+	async _inspectExec() {
+		return this._exec.inspect();
+	}
 };
-
-// src/sandbox/index.ts
-var LOG_PREFIX = "[DockerSandbox]";
-var DockerSandbox = class _DockerSandbox extends workspace.MastraSandbox {
-  id;
-  name = "DockerSandbox";
-  provider = "docker";
-  status = "pending";
-  /** Underlying Docker client */
-  _docker;
-  /** Container reference (set after start) */
-  _container = null;
-  /** Configuration */
-  _containerName;
-  _image;
-  _command;
-  _env;
-  _volumes;
-  _network;
-  _privileged;
-  _privilegedWasSet;
-  _memory;
-  _memorySwap;
-  _cpuShares;
-  _cpuQuota;
-  _cpuPeriod;
-  _pidsLimit;
-  _readonlyRootfs;
-  _capDrop;
-  _capAdd;
-  _securityOpt;
-  _ulimits;
-  _tmpfs;
-  _workingDir;
-  _labels;
-  _instructionsOverride;
-  _constructorOptions;
-  constructor(options = {}) {
-    const processManager = new DockerProcessManager({
-      env: options.env ?? {},
-      defaultTimeout: options.timeout ?? 3e5
-    });
-    super({
-      ...options,
-      name: "DockerSandbox",
-      processes: processManager
-    });
-    this.id = options.id ?? this._generateId();
-    this._containerName = sanitizeContainerName(options.name ?? this.id);
-    this._image = options.image ?? "node:22-slim";
-    this._command = options.command ?? ["sleep", "infinity"];
-    this._env = options.env ?? {};
-    this._volumes = options.volumes ?? {};
-    this._network = options.network;
-    this._privileged = options.privileged ?? false;
-    this._privilegedWasSet = options.privileged !== void 0;
-    this._memory = options.memory;
-    this._memorySwap = options.memorySwap;
-    this._cpuShares = options.cpuShares;
-    this._cpuQuota = options.cpuQuota;
-    this._cpuPeriod = options.cpuPeriod;
-    this._pidsLimit = options.pidsLimit;
-    this._readonlyRootfs = options.readonlyRootfs;
-    this._capDrop = options.capDrop;
-    this._capAdd = options.capAdd;
-    this._securityOpt = options.securityOpt;
-    this._ulimits = options.ulimits;
-    this._tmpfs = options.tmpfs;
-    this._workingDir = options.workingDir ?? "/workspace";
-    this._labels = {
-      ...options.labels,
-      "mastra.sandbox": "true",
-      "mastra.sandbox.id": this.id
-    };
-    this._instructionsOverride = options.instructions;
-    this._docker = new Docker__default.default(options.dockerOptions);
-    this._constructorOptions = { ...options };
-  }
-  /**
-   * Construct a sibling `DockerSandbox` that inherits this sandbox's
-   * configuration (image, resource limits, security options, labels,
-   * connection options) with per-instance overrides.
-   *
-   * Performs no I/O — the sandbox clone provisions (or reconnects to an
-   * existing container labelled with the same logical `id`) on its own
-   * `start()`. Use it when one configured sandbox acts as the template for a
-   * fleet of independent sandboxes (e.g. one per project).
-   *
-   * `options.idleTimeoutMinutes` is ignored (Docker containers have no
-   * provider-side idle teardown; `timeout` here is a command timeout), and
-   * `options.sandboxId` is ignored because reconnection is by logical `id`.
-   */
-  clone(options = {}) {
-    const { id: _id, name: _name, ...base } = this._constructorOptions;
-    return new _DockerSandbox({
-      ...base,
-      ...options.id !== void 0 && { id: options.id },
-      ...options.env !== void 0 && { env: options.env }
-    });
-  }
-  /**
-   * Get the underlying Docker container for direct access.
-   * @throws {SandboxNotReadyError} If the sandbox has not been started.
-   */
-  get container() {
-    if (!this._container) {
-      throw new workspace.SandboxNotReadyError(this.id);
-    }
-    return this._container;
-  }
-  // ---------------------------------------------------------------------------
-  // Lifecycle
-  // ---------------------------------------------------------------------------
-  async start() {
-    this.logger.debug(`${LOG_PREFIX} Starting sandbox ${this.id}...`);
-    const existing = await this._findExistingContainer();
-    if (existing) {
-      this.logger.debug(`${LOG_PREFIX} Found existing container ${existing.Id}`);
-      this._container = this._docker.getContainer(existing.Id);
-      const info = await this._container.inspect();
-      this._warnOnPrivilegedHardeningConflict(info.HostConfig?.Privileged ?? this._privileged);
-      this._warnOnReconnectedHostConfigMismatch(existing.Id, info.HostConfig);
-      const actualState = info.State?.Running ? "running" : "stopped";
-      if (actualState !== "running") {
-        this.logger.debug(`${LOG_PREFIX} Container exists but not running (${actualState}), starting...`);
-        await this._container.start();
-      }
-      this.processes.setContainer(this._container);
-      this.logger.debug(`${LOG_PREFIX} Reconnected to container ${existing.Id}`);
-      return;
-    }
-    this._warnOnPrivilegedHardeningConflict(this._privileged);
-    await this._ensureImage();
-    const envArray = Object.entries(this._env).map(([k, v]) => `${k}=${v}`);
-    const binds = Object.entries(this._volumes).map(([host, container]) => `${host}:${container}`);
-    this.logger.debug(`${LOG_PREFIX} Creating container with image ${this._image}...`);
-    this._container = await this._docker.createContainer({
-      name: this._containerName,
-      Image: this._image,
-      Cmd: this._command,
-      Env: envArray,
-      WorkingDir: this._workingDir,
-      Labels: this._labels,
-      HostConfig: {
-        Binds: binds.length > 0 ? binds : void 0,
-        NetworkMode: this._network,
-        Privileged: this._privileged,
-        Memory: this._memory,
-        MemorySwap: this._memorySwap,
-        CpuShares: this._cpuShares,
-        CpuQuota: this._cpuQuota,
-        CpuPeriod: this._cpuPeriod,
-        PidsLimit: this._pidsLimit,
-        ReadonlyRootfs: this._readonlyRootfs,
-        CapDrop: this._capDrop,
-        CapAdd: this._capAdd,
-        SecurityOpt: this._securityOpt,
-        Ulimits: this._ulimits?.map(toDockerUlimit),
-        Tmpfs: this._tmpfs
-      },
-      // Keep stdin open for interactive use
-      OpenStdin: true,
-      Tty: false
-    });
-    await this._container.start();
-    this.processes.setContainer(this._container);
-    this.logger.debug(`${LOG_PREFIX} Container started: ${this._container.id}`);
-  }
-  _warnOnPrivilegedHardeningConflict(effectivePrivileged) {
-    if (!effectivePrivileged) return;
-    const conflictedHostConfigFields = [
-      this._capDrop && this._capDrop.length > 0 ? "CapDrop" : void 0,
-      this._capAdd && this._capAdd.length > 0 ? "CapAdd" : void 0,
-      this._securityOpt && this._securityOpt.length > 0 ? "SecurityOpt" : void 0
-    ].filter((field) => field !== void 0);
-    if (conflictedHostConfigFields.length === 0) return;
-    const optionNames = conflictedHostConfigFields.map(toDockerSandboxOptionName);
-    this.logger.warn(
-      `${LOG_PREFIX} Privileged containers can bypass some requested hardening controls: ${optionNames.join(", ")}`,
-      { fields: optionNames, hostConfigFields: conflictedHostConfigFields }
-    );
-  }
-  _warnOnReconnectedHostConfigMismatch(containerId, hostConfig) {
-    if (!hostConfig) return;
-    const mismatchedHostConfigFields = this._requestedHardeningHostConfigEntries(hostConfig).filter(([field, requestedValue]) => !isHostConfigValueEqual(field, hostConfig[field], requestedValue)).map(([field]) => field);
-    if (mismatchedHostConfigFields.length === 0) return;
-    if (!this._privilegedWasSet && hostConfig.Privileged === true && mismatchedHostConfigFields.includes("Privileged")) {
-      this.logger.warn(
-        `${LOG_PREFIX} Reconnected to existing container ${containerId}; the existing container is privileged, but this DockerSandbox did not request privileged mode. Destroy and recreate the sandbox to apply the default non-privileged mode.`,
-        { containerId, fields: ["privileged"], hostConfigFields: ["Privileged"] }
-      );
-    }
-    const remainingMismatchedHostConfigFields = mismatchedHostConfigFields.filter(
-      (field) => field !== "Privileged" || this._privilegedWasSet
-    );
-    if (remainingMismatchedHostConfigFields.length === 0) return;
-    const mismatchedOptions = remainingMismatchedHostConfigFields.map(toDockerSandboxOptionName);
-    this.logger.warn(
-      `${LOG_PREFIX} Reconnected to existing container ${containerId}; requested Docker option(s) ${mismatchedOptions.join(
-        ", "
-      )} differ from inspected HostConfig field(s) ${remainingMismatchedHostConfigFields.join(
-        ", "
-      )} and cannot be applied to the existing container. Destroy and recreate the sandbox to apply them.`,
-      { containerId, fields: mismatchedOptions, hostConfigFields: remainingMismatchedHostConfigFields }
-    );
-  }
-  _requestedHardeningHostConfigEntries(hostConfig) {
-    const entries = [
-      ["Memory", this._memory],
-      ["MemorySwap", this._memorySwap],
-      ["CpuShares", this._cpuShares],
-      ["CpuQuota", this._cpuQuota],
-      ["CpuPeriod", this._cpuPeriod],
-      ["PidsLimit", this._pidsLimit],
-      ["ReadonlyRootfs", this._readonlyRootfs],
-      ["CapDrop", this._capDrop],
-      ["CapAdd", this._capAdd],
-      ["SecurityOpt", this._securityOpt],
-      ["Ulimits", this._ulimits],
-      ["Tmpfs", this._tmpfs]
-    ];
-    if (this._privilegedWasSet || hostConfig?.Privileged === true) {
-      entries.unshift(["Privileged", this._privileged]);
-    }
-    return entries.filter((entry) => isPresentHostConfigValue(entry[1]));
-  }
-  async stop() {
-    const container = await this._resolveContainer();
-    if (!container) return;
-    this.logger.debug(`${LOG_PREFIX} Stopping container ${container.id}...`);
-    try {
-      await container.stop({ t: 10 });
-    } catch (error) {
-      if (!isContainerNotRunningError(error)) {
-        throw error;
-      }
-    }
-    this.processes.reset();
-    this.logger.debug(`${LOG_PREFIX} Container stopped`);
-  }
-  async destroy() {
-    const container = await this._resolveContainer();
-    if (!container) return;
-    this.logger.debug(`${LOG_PREFIX} Destroying container ${container.id}...`);
-    try {
-      await container.remove({ force: true, v: true });
-    } catch (error) {
-      if (!isContainerNotFoundError(error)) {
-        throw error;
-      }
-    }
-    this.processes.reset();
-    this._container = null;
-    this.logger.debug(`${LOG_PREFIX} Container destroyed`);
-  }
-  // ---------------------------------------------------------------------------
-  // Instructions
-  // ---------------------------------------------------------------------------
-  getInstructions(opts) {
-    const defaultInstructions = [
-      `You are working inside a Docker container (image: ${this._image}).`,
-      `The working directory is ${this._workingDir}.`,
-      "You can execute shell commands using executeCommand().",
-      "You can spawn background processes using processes.spawn()."
-    ].join("\n");
-    if (this._instructionsOverride === void 0) return defaultInstructions;
-    if (typeof this._instructionsOverride === "string") return this._instructionsOverride;
-    return this._instructionsOverride({ defaultInstructions, requestContext: opts?.requestContext });
-  }
-  // ---------------------------------------------------------------------------
-  // Info
-  // ---------------------------------------------------------------------------
-  async getInfo() {
-    const info = {
-      id: this.id,
-      name: this.name,
-      provider: this.provider,
-      status: this.status,
-      createdAt: /* @__PURE__ */ new Date(),
-      metadata: {
-        image: this._image,
-        workingDir: this._workingDir,
-        labels: this._labels
-      }
-    };
-    if (this._container) {
-      try {
-        const inspect = await this._container.inspect();
-        info.createdAt = new Date(inspect.Created);
-        info.metadata = {
-          ...info.metadata,
-          containerId: inspect.Id,
-          containerName: inspect.Name,
-          state: inspect.State.Status
-        };
-      } catch {
-      }
-    }
-    return info;
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  _generateId() {
-    return `docker-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  }
-  /**
-   * Resolve the container reference, looking up by label if `_container` is unset.
-   * This ensures `stop()` and `destroy()` work even when the instance was created
-   * with an existing container's ID but `start()` was never called.
-   */
-  async _resolveContainer() {
-    if (this._container) return this._container;
-    const existing = await this._findExistingContainer();
-    if (!existing) return null;
-    this._container = this._docker.getContainer(existing.Id);
-    return this._container;
-  }
-  /**
-   * Find an existing container matching this sandbox's ID via labels.
-   */
-  async _findExistingContainer() {
-    try {
-      const containers = await this._docker.listContainers({
-        all: true,
-        filters: {
-          label: [`mastra.sandbox.id=${this.id}`]
-        }
-      });
-      return containers[0] ?? null;
-    } catch (error) {
-      this.logger.debug(
-        `${LOG_PREFIX} Failed to list containers: ${error instanceof Error ? error.message : String(error)}`
-      );
-      throw error;
-    }
-  }
-  /**
-   * Ensure the Docker image is available locally. Pulls if needed.
-   */
-  async _ensureImage() {
-    try {
-      await this._docker.getImage(this._image).inspect();
-      this.logger.debug(`${LOG_PREFIX} Image ${this._image} available locally`);
-    } catch (error) {
-      if (!isImageNotFoundError(error)) {
-        throw error;
-      }
-      this.logger.debug(`${LOG_PREFIX} Pulling image ${this._image}...`);
-      try {
-        const stream = await this._docker.pull(this._image);
-        await new Promise((resolve, reject) => {
-          this._docker.modem.followProgress(stream, (err) => {
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-        this.logger.debug(`${LOG_PREFIX} Image ${this._image} pulled successfully`);
-      } catch (error2) {
-        throw new workspace.SandboxError(
-          `Failed to pull Docker image '${this._image}': ${error2 instanceof Error ? error2.message : String(error2)}`,
-          "NOT_READY",
-          { image: this._image, reason: "image_pull_failed" }
-        );
-      }
-    }
-  }
+/**
+* Docker implementation of SandboxProcessManager.
+* Uses `container.exec()` with stream-based I/O.
+*/
+var DockerProcessManager = class extends _mastra_core_workspace.SandboxProcessManager {
+	_container = null;
+	_defaultTimeout;
+	constructor(options) {
+		super(options);
+		this._defaultTimeout = options.defaultTimeout ?? 0;
+	}
+	/** @internal Called by DockerSandbox after container is ready */
+	setContainer(container) {
+		this._container = container;
+	}
+	/** Get the container, throwing if not set */
+	get container() {
+		if (!this._container) throw new Error("Docker container not available. Has the sandbox been started?");
+		return this._container;
+	}
+	async spawn(command, options = {}) {
+		const container = this.container;
+		const mergedEnv = {
+			...this.env,
+			...options.env
+		};
+		const envArray = Object.entries(mergedEnv).filter((entry) => entry[1] !== void 0).map(([k, v]) => `${k}=${v}`);
+		const exec = await container.exec({
+			Cmd: [
+				"sh",
+				"-c",
+				command
+			],
+			AttachStdout: true,
+			AttachStderr: true,
+			AttachStdin: true,
+			Tty: false,
+			Env: envArray.length > 0 ? envArray : void 0,
+			WorkingDir: options.cwd
+		});
+		const stream = await exec.start({
+			hijack: true,
+			stdin: true
+		});
+		const startTime = Date.now();
+		const handle = new DockerProcessHandle(exec, container, startTime, stream, options);
+		handle._setExecStream(stream);
+		const waitPromise = new Promise((resolve) => {
+			const buffer = [];
+			stream.on("data", (chunk) => {
+				buffer.push(chunk);
+				let combined = Buffer.concat(buffer);
+				buffer.length = 0;
+				while (combined.length >= 8) {
+					const type = combined[0];
+					const size = combined.readUInt32BE(4);
+					if (combined.length < 8 + size) {
+						buffer.push(combined);
+						break;
+					}
+					const payload = combined.subarray(8, 8 + size).toString("utf-8");
+					if (type === 1) handle.emitStdout(payload);
+					else if (type === 2) handle.emitStderr(payload);
+					combined = combined.subarray(8 + size);
+				}
+				if (combined.length > 0 && buffer.length === 0) buffer.push(combined);
+			});
+			stream.on("end", async () => {
+				try {
+					const exitCode = (await exec.inspect()).ExitCode ?? 1;
+					handle._setExitCode(exitCode);
+					resolve({
+						success: exitCode === 0,
+						exitCode,
+						stdout: handle.stdout,
+						stderr: handle.stderr,
+						executionTimeMs: Date.now() - startTime
+					});
+				} catch {
+					handle._setExitCode(1);
+					resolve({
+						success: false,
+						exitCode: 1,
+						stdout: handle.stdout,
+						stderr: handle.stderr,
+						executionTimeMs: Date.now() - startTime
+					});
+				}
+			});
+			stream.on("close", () => {
+				if (handle.exitCode !== void 0) return;
+				if (!handle._killed) return;
+				handle._setExitCode(137);
+				resolve({
+					success: false,
+					exitCode: 137,
+					stdout: handle.stdout,
+					stderr: handle.stderr,
+					executionTimeMs: Date.now() - startTime,
+					killed: true,
+					timedOut: handle._timedOut
+				});
+			});
+			stream.on("error", () => {
+				if (handle.exitCode !== void 0) return;
+				handle._setExitCode(1);
+				resolve({
+					success: false,
+					exitCode: 1,
+					stdout: handle.stdout,
+					stderr: handle.stderr || "Stream error",
+					executionTimeMs: Date.now() - startTime
+				});
+			});
+		});
+		const resolvedTimeout = options.timeout ?? this._defaultTimeout;
+		if (resolvedTimeout > 0) {
+			const timer = setTimeout(() => {
+				if (handle.exitCode === void 0) {
+					handle._killed = true;
+					handle._timedOut = true;
+					handle.kill().catch(() => {});
+					handle._destroyStream();
+				}
+			}, resolvedTimeout);
+			waitPromise.then(() => clearTimeout(timer));
+		}
+		handle._setWaitPromise(waitPromise);
+		this._tracked.set(handle.pid, handle);
+		return handle;
+	}
+	/** Clear all tracked process handles and release the container reference (e.g., after container stop/destroy) */
+	reset() {
+		this._tracked.clear();
+		this._container = null;
+	}
+	async list() {
+		const results = [];
+		for (const [pid, handle] of this._tracked) results.push({
+			pid,
+			command: handle.command,
+			running: handle.exitCode === void 0,
+			exitCode: handle.exitCode
+		});
+		return results;
+	}
+};
+//#endregion
+//#region src/sandbox/index.ts
+/**
+* Docker Sandbox Provider
+*
+* A Docker-based sandbox implementation that uses long-lived containers
+* with `docker exec` for command execution. Targets local development,
+* CI/CD, air-gapped deployments, and cost-sensitive scenarios where
+* cloud sandboxes are overkill.
+*
+* @see https://docs.docker.com/engine/api/
+*/
+const LOG_PREFIX = "[DockerSandbox]";
+/**
+* Docker sandbox implementation using long-lived containers.
+*
+* Features:
+* - Long-lived container with `docker exec` for commands
+* - Bind mount support via Docker volumes
+* - Reconnection to existing containers by ID/name
+* - Container label tracking for discovery
+*
+* @example Basic usage
+* ```typescript
+* import { Workspace } from '@mastra/core/workspace';
+* import { DockerSandbox } from '@mastra/docker';
+*
+* const sandbox = new DockerSandbox({
+*   image: 'node:22-slim',
+*   timeout: 60000,
+* });
+*
+* const workspace = new Workspace({ sandbox });
+* const result = await workspace.executeCode('console.log("Hello!")');
+* ```
+*
+* @example With bind mounts
+* ```typescript
+* const sandbox = new DockerSandbox({
+*   image: 'node:22-slim',
+*   volumes: { '/my/project': '/workspace/project' },
+* });
+* ```
+*/
+var DockerSandbox = class DockerSandbox extends _mastra_core_workspace.MastraSandbox {
+	id;
+	name = "DockerSandbox";
+	provider = "docker";
+	status = "pending";
+	/** Underlying Docker client */
+	_docker;
+	/** Container reference (set after start) */
+	_container = null;
+	/** Configuration */
+	_containerName;
+	_image;
+	_command;
+	_env;
+	_volumes;
+	_network;
+	_privileged;
+	_privilegedWasSet;
+	_memory;
+	_memorySwap;
+	_cpuShares;
+	_cpuQuota;
+	_cpuPeriod;
+	_pidsLimit;
+	_readonlyRootfs;
+	_capDrop;
+	_capAdd;
+	_securityOpt;
+	_ulimits;
+	_tmpfs;
+	_workingDir;
+	_labels;
+	_instructionsOverride;
+	_constructorOptions;
+	constructor(options = {}) {
+		const processManager = new DockerProcessManager({
+			env: options.env ?? {},
+			defaultTimeout: options.timeout ?? 3e5
+		});
+		super({
+			...options,
+			name: "DockerSandbox",
+			processes: processManager
+		});
+		this.id = options.id ?? this._generateId();
+		this._containerName = sanitizeContainerName(options.name ?? this.id);
+		this._image = options.image ?? "node:22-slim";
+		this._command = options.command ?? ["sleep", "infinity"];
+		this._env = options.env ?? {};
+		this._volumes = options.volumes ?? {};
+		this._network = options.network;
+		this._privileged = options.privileged ?? false;
+		this._privilegedWasSet = options.privileged !== void 0;
+		this._memory = options.memory;
+		this._memorySwap = options.memorySwap;
+		this._cpuShares = options.cpuShares;
+		this._cpuQuota = options.cpuQuota;
+		this._cpuPeriod = options.cpuPeriod;
+		this._pidsLimit = options.pidsLimit;
+		this._readonlyRootfs = options.readonlyRootfs;
+		this._capDrop = options.capDrop;
+		this._capAdd = options.capAdd;
+		this._securityOpt = options.securityOpt;
+		this._ulimits = options.ulimits;
+		this._tmpfs = options.tmpfs;
+		this._workingDir = options.workingDir ?? "/workspace";
+		this._labels = {
+			...options.labels,
+			"mastra.sandbox": "true",
+			"mastra.sandbox.id": this.id
+		};
+		this._instructionsOverride = options.instructions;
+		this._docker = new dockerode.default(options.dockerOptions);
+		this._constructorOptions = { ...options };
+	}
+	/**
+	* Construct a sibling `DockerSandbox` that inherits this sandbox's
+	* configuration (image, resource limits, security options, labels,
+	* connection options) with per-instance overrides.
+	*
+	* Performs no I/O — the sandbox clone provisions (or reconnects to an
+	* existing container labelled with the same logical `id`) on its own
+	* `start()`. Use it when one configured sandbox acts as the template for a
+	* fleet of independent sandboxes (e.g. one per project).
+	*
+	* `options.idleTimeoutMinutes` is ignored (Docker containers have no
+	* provider-side idle teardown; `timeout` here is a command timeout), and
+	* `options.sandboxId` is ignored because reconnection is by logical `id`.
+	*/
+	clone(options = {}) {
+		const { id: _id, name: _name, ...base } = this._constructorOptions;
+		return new DockerSandbox({
+			...base,
+			...options.id !== void 0 && { id: options.id },
+			...options.env !== void 0 && { env: options.env }
+		});
+	}
+	/**
+	* Get the underlying Docker container for direct access.
+	* @throws {SandboxNotReadyError} If the sandbox has not been started.
+	*/
+	get container() {
+		if (!this._container) throw new _mastra_core_workspace.SandboxNotReadyError(this.id);
+		return this._container;
+	}
+	async start() {
+		this.logger.debug(`${LOG_PREFIX} Starting sandbox ${this.id}...`);
+		const existing = await this._findExistingContainer();
+		if (existing) {
+			this.logger.debug(`${LOG_PREFIX} Found existing container ${existing.Id}`);
+			this._container = this._docker.getContainer(existing.Id);
+			const info = await this._container.inspect();
+			this._warnOnPrivilegedHardeningConflict(info.HostConfig?.Privileged ?? this._privileged);
+			this._warnOnReconnectedHostConfigMismatch(existing.Id, info.HostConfig);
+			const actualState = info.State?.Running ? "running" : "stopped";
+			if (actualState !== "running") {
+				this.logger.debug(`${LOG_PREFIX} Container exists but not running (${actualState}), starting...`);
+				await this._container.start();
+			}
+			this.processes.setContainer(this._container);
+			this.logger.debug(`${LOG_PREFIX} Reconnected to container ${existing.Id}`);
+			return;
+		}
+		this._warnOnPrivilegedHardeningConflict(this._privileged);
+		await this._ensureImage();
+		const envArray = Object.entries(this._env).map(([k, v]) => `${k}=${v}`);
+		const binds = Object.entries(this._volumes).map(([host, container]) => `${host}:${container}`);
+		this.logger.debug(`${LOG_PREFIX} Creating container with image ${this._image}...`);
+		this._container = await this._docker.createContainer({
+			name: this._containerName,
+			Image: this._image,
+			Cmd: this._command,
+			Env: envArray,
+			WorkingDir: this._workingDir,
+			Labels: this._labels,
+			HostConfig: {
+				Binds: binds.length > 0 ? binds : void 0,
+				NetworkMode: this._network,
+				Privileged: this._privileged,
+				Memory: this._memory,
+				MemorySwap: this._memorySwap,
+				CpuShares: this._cpuShares,
+				CpuQuota: this._cpuQuota,
+				CpuPeriod: this._cpuPeriod,
+				PidsLimit: this._pidsLimit,
+				ReadonlyRootfs: this._readonlyRootfs,
+				CapDrop: this._capDrop,
+				CapAdd: this._capAdd,
+				SecurityOpt: this._securityOpt,
+				Ulimits: this._ulimits?.map(toDockerUlimit),
+				Tmpfs: this._tmpfs
+			},
+			OpenStdin: true,
+			Tty: false
+		});
+		await this._container.start();
+		this.processes.setContainer(this._container);
+		this.logger.debug(`${LOG_PREFIX} Container started: ${this._container.id}`);
+	}
+	_warnOnPrivilegedHardeningConflict(effectivePrivileged) {
+		if (!effectivePrivileged) return;
+		const conflictedHostConfigFields = [
+			this._capDrop && this._capDrop.length > 0 ? "CapDrop" : void 0,
+			this._capAdd && this._capAdd.length > 0 ? "CapAdd" : void 0,
+			this._securityOpt && this._securityOpt.length > 0 ? "SecurityOpt" : void 0
+		].filter((field) => field !== void 0);
+		if (conflictedHostConfigFields.length === 0) return;
+		const optionNames = conflictedHostConfigFields.map(toDockerSandboxOptionName);
+		this.logger.warn(`${LOG_PREFIX} Privileged containers can bypass some requested hardening controls: ${optionNames.join(", ")}`, {
+			fields: optionNames,
+			hostConfigFields: conflictedHostConfigFields
+		});
+	}
+	_warnOnReconnectedHostConfigMismatch(containerId, hostConfig) {
+		if (!hostConfig) return;
+		const mismatchedHostConfigFields = this._requestedHardeningHostConfigEntries(hostConfig).filter(([field, requestedValue]) => !isHostConfigValueEqual(field, hostConfig[field], requestedValue)).map(([field]) => field);
+		if (mismatchedHostConfigFields.length === 0) return;
+		if (!this._privilegedWasSet && hostConfig.Privileged === true && mismatchedHostConfigFields.includes("Privileged")) this.logger.warn(`${LOG_PREFIX} Reconnected to existing container ${containerId}; the existing container is privileged, but this DockerSandbox did not request privileged mode. Destroy and recreate the sandbox to apply the default non-privileged mode.`, {
+			containerId,
+			fields: ["privileged"],
+			hostConfigFields: ["Privileged"]
+		});
+		const remainingMismatchedHostConfigFields = mismatchedHostConfigFields.filter((field) => field !== "Privileged" || this._privilegedWasSet);
+		if (remainingMismatchedHostConfigFields.length === 0) return;
+		const mismatchedOptions = remainingMismatchedHostConfigFields.map(toDockerSandboxOptionName);
+		this.logger.warn(`${LOG_PREFIX} Reconnected to existing container ${containerId}; requested Docker option(s) ${mismatchedOptions.join(", ")} differ from inspected HostConfig field(s) ${remainingMismatchedHostConfigFields.join(", ")} and cannot be applied to the existing container. Destroy and recreate the sandbox to apply them.`, {
+			containerId,
+			fields: mismatchedOptions,
+			hostConfigFields: remainingMismatchedHostConfigFields
+		});
+	}
+	_requestedHardeningHostConfigEntries(hostConfig) {
+		const entries = [
+			["Memory", this._memory],
+			["MemorySwap", this._memorySwap],
+			["CpuShares", this._cpuShares],
+			["CpuQuota", this._cpuQuota],
+			["CpuPeriod", this._cpuPeriod],
+			["PidsLimit", this._pidsLimit],
+			["ReadonlyRootfs", this._readonlyRootfs],
+			["CapDrop", this._capDrop],
+			["CapAdd", this._capAdd],
+			["SecurityOpt", this._securityOpt],
+			["Ulimits", this._ulimits],
+			["Tmpfs", this._tmpfs]
+		];
+		if (this._privilegedWasSet || hostConfig?.Privileged === true) entries.unshift(["Privileged", this._privileged]);
+		return entries.filter((entry) => isPresentHostConfigValue(entry[1]));
+	}
+	async stop() {
+		const container = await this._resolveContainer();
+		if (!container) return;
+		this.logger.debug(`${LOG_PREFIX} Stopping container ${container.id}...`);
+		try {
+			await container.stop({ t: 10 });
+		} catch (error) {
+			if (!isContainerNotRunningError(error)) throw error;
+		}
+		this.processes.reset();
+		this.logger.debug(`${LOG_PREFIX} Container stopped`);
+	}
+	async destroy() {
+		const container = await this._resolveContainer();
+		if (!container) return;
+		this.logger.debug(`${LOG_PREFIX} Destroying container ${container.id}...`);
+		try {
+			await container.remove({
+				force: true,
+				v: true
+			});
+		} catch (error) {
+			if (!isContainerNotFoundError(error)) throw error;
+		}
+		this.processes.reset();
+		this._container = null;
+		this.logger.debug(`${LOG_PREFIX} Container destroyed`);
+	}
+	getInstructions(opts) {
+		const defaultInstructions = [
+			`You are working inside a Docker container (image: ${this._image}).`,
+			`The working directory is ${this._workingDir}.`,
+			"You can execute shell commands using executeCommand().",
+			"You can spawn background processes using processes.spawn()."
+		].join("\n");
+		if (this._instructionsOverride === void 0) return defaultInstructions;
+		if (typeof this._instructionsOverride === "string") return this._instructionsOverride;
+		return this._instructionsOverride({
+			defaultInstructions,
+			requestContext: opts?.requestContext
+		});
+	}
+	async getInfo() {
+		const info = {
+			id: this.id,
+			name: this.name,
+			provider: this.provider,
+			status: this.status,
+			createdAt: /* @__PURE__ */ new Date(),
+			metadata: {
+				image: this._image,
+				workingDir: this._workingDir,
+				labels: this._labels
+			}
+		};
+		if (this._container) try {
+			const inspect = await this._container.inspect();
+			info.createdAt = new Date(inspect.Created);
+			info.metadata = {
+				...info.metadata,
+				containerId: inspect.Id,
+				containerName: inspect.Name,
+				state: inspect.State.Status
+			};
+		} catch {}
+		return info;
+	}
+	_generateId() {
+		return `docker-sandbox-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+	}
+	/**
+	* Resolve the container reference, looking up by label if `_container` is unset.
+	* This ensures `stop()` and `destroy()` work even when the instance was created
+	* with an existing container's ID but `start()` was never called.
+	*/
+	async _resolveContainer() {
+		if (this._container) return this._container;
+		const existing = await this._findExistingContainer();
+		if (!existing) return null;
+		this._container = this._docker.getContainer(existing.Id);
+		return this._container;
+	}
+	/**
+	* Find an existing container matching this sandbox's ID via labels.
+	*/
+	async _findExistingContainer() {
+		try {
+			return (await this._docker.listContainers({
+				all: true,
+				filters: { label: [`mastra.sandbox.id=${this.id}`] }
+			}))[0] ?? null;
+		} catch (error) {
+			this.logger.debug(`${LOG_PREFIX} Failed to list containers: ${error instanceof Error ? error.message : String(error)}`);
+			throw error;
+		}
+	}
+	/**
+	* Ensure the Docker image is available locally. Pulls if needed.
+	*/
+	async _ensureImage() {
+		try {
+			await this._docker.getImage(this._image).inspect();
+			this.logger.debug(`${LOG_PREFIX} Image ${this._image} available locally`);
+		} catch (error) {
+			if (!isImageNotFoundError(error)) throw error;
+			this.logger.debug(`${LOG_PREFIX} Pulling image ${this._image}...`);
+			try {
+				const stream = await this._docker.pull(this._image);
+				await new Promise((resolve, reject) => {
+					this._docker.modem.followProgress(stream, (err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+				this.logger.debug(`${LOG_PREFIX} Image ${this._image} pulled successfully`);
+			} catch (error) {
+				throw new _mastra_core_workspace.SandboxError(`Failed to pull Docker image '${this._image}': ${error instanceof Error ? error.message : String(error)}`, "NOT_READY", {
+					image: this._image,
+					reason: "image_pull_failed"
+				});
+			}
+		}
+	}
 };
 function sanitizeContainerName(value) {
-  const replaced = value.replace(/[^a-zA-Z0-9_.-]/g, "-");
-  const withLeading = /^[a-zA-Z0-9]/.test(replaced) ? replaced : `s-${replaced}`;
-  return withLeading.length >= 2 ? withLeading : `${withLeading}-sandbox`;
+	const replaced = value.replace(/[^a-zA-Z0-9_.-]/g, "-");
+	const withLeading = /^[a-zA-Z0-9]/.test(replaced) ? replaced : `s-${replaced}`;
+	return withLeading.length >= 2 ? withLeading : `${withLeading}-sandbox`;
 }
 function isContainerNotRunningError(error) {
-  if (error instanceof Error) {
-    return error.message.includes("is not running") || error.message.includes("container already stopped");
-  }
-  return false;
+	if (error instanceof Error) return error.message.includes("is not running") || error.message.includes("container already stopped");
+	return false;
 }
 function isContainerNotFoundError(error) {
-  if (error instanceof Error) {
-    const msg = error.message.toLowerCase();
-    return msg.includes("no such container") || msg.includes("removal") && msg.includes("is already in progress");
-  }
-  return false;
+	if (error instanceof Error) {
+		const msg = error.message.toLowerCase();
+		return msg.includes("no such container") || msg.includes("removal") && msg.includes("is already in progress");
+	}
+	return false;
 }
 function isImageNotFoundError(error) {
-  if (error instanceof Error) {
-    return error.message.toLowerCase().includes("no such image");
-  }
-  return false;
+	if (error instanceof Error) return error.message.toLowerCase().includes("no such image");
+	return false;
 }
 function isHostConfigValueEqual(field, actual, expected) {
-  return util.isDeepStrictEqual(normalizeHostConfigValue(field, actual), normalizeHostConfigValue(field, expected));
+	return (0, util.isDeepStrictEqual)(normalizeHostConfigValue(field, actual), normalizeHostConfigValue(field, expected));
 }
 function normalizeHostConfigValue(field, value) {
-  if (value == null) return void 0;
-  if ((field === "CapAdd" || field === "CapDrop") && Array.isArray(value)) {
-    if (value.length === 0) return void 0;
-    return value.map(normalizeCapability).sort();
-  }
-  if (field === "SecurityOpt" && Array.isArray(value)) {
-    if (value.length === 0) return void 0;
-    return value.map(normalizeSecurityOpt).sort();
-  }
-  if (field === "Tmpfs" && value && typeof value === "object" && !Array.isArray(value)) {
-    if (Object.keys(value).length === 0) return void 0;
-    return Object.fromEntries(
-      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([path, options]) => [path, typeof options === "string" ? normalizeTmpfsOptions(options) : options])
-    );
-  }
-  if (Array.isArray(value)) {
-    if (field === "Ulimits" && value.length === 0) return void 0;
-    return value.map((nestedValue) => normalizeHostConfigValue(field, nestedValue)).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-  }
-  if (field === "Ulimits" && value && typeof value === "object") {
-    return normalizeUlimit(value);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nestedValue]) => [key, normalizeHostConfigValue(field, nestedValue)])
-    );
-  }
-  return value;
+	if (value == null) return void 0;
+	if ((field === "CapAdd" || field === "CapDrop") && Array.isArray(value)) {
+		if (value.length === 0) return void 0;
+		return value.map(normalizeCapability).sort();
+	}
+	if (field === "SecurityOpt" && Array.isArray(value)) {
+		if (value.length === 0) return void 0;
+		return value.map(normalizeSecurityOpt).sort();
+	}
+	if (field === "Tmpfs" && value && typeof value === "object" && !Array.isArray(value)) {
+		if (Object.keys(value).length === 0) return void 0;
+		return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([path, options]) => [path, typeof options === "string" ? normalizeTmpfsOptions(options) : options]));
+	}
+	if (Array.isArray(value)) {
+		if (field === "Ulimits" && value.length === 0) return void 0;
+		return value.map((nestedValue) => normalizeHostConfigValue(field, nestedValue)).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+	}
+	if (field === "Ulimits" && value && typeof value === "object") return normalizeUlimit(value);
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nestedValue]) => [key, normalizeHostConfigValue(field, nestedValue)]));
+	return value;
 }
 function isPresentHostConfigValue(value) {
-  if (value == null) return false;
-  if (Array.isArray(value)) return value.length > 0;
-  if (value && typeof value === "object") return Object.keys(value).length > 0;
-  return true;
+	if (value == null) return false;
+	if (Array.isArray(value)) return value.length > 0;
+	if (value && typeof value === "object") return Object.keys(value).length > 0;
+	return true;
 }
 function normalizeCapability(capability) {
-  return typeof capability === "string" ? capability.toUpperCase().replace(/^CAP_/, "") : capability;
+	return typeof capability === "string" ? capability.toUpperCase().replace(/^CAP_/, "") : capability;
 }
 function normalizeTmpfsOptions(options) {
-  return options.split(",").map((option) => option.trim()).filter(Boolean).sort().join(",");
+	return options.split(",").map((option) => option.trim()).filter(Boolean).sort().join(",");
 }
 function normalizeSecurityOpt(option) {
-  if (typeof option !== "string") return option;
-  const noNewPrivileges = option.match(/^no-new-privileges[:=](.+)$/i);
-  if (noNewPrivileges) {
-    return `no-new-privileges=${noNewPrivileges[1]}`;
-  }
-  return option;
+	if (typeof option !== "string") return option;
+	const noNewPrivileges = option.match(/^no-new-privileges[:=](.+)$/i);
+	if (noNewPrivileges) return `no-new-privileges=${noNewPrivileges[1]}`;
+	return option;
 }
 function normalizeUlimit(value) {
-  const record = value;
-  return {
-    name: record.name ?? record.Name,
-    soft: record.soft ?? record.Soft,
-    hard: record.hard ?? record.Hard
-  };
+	const record = value;
+	return {
+		name: record.name ?? record.Name,
+		soft: record.soft ?? record.Soft,
+		hard: record.hard ?? record.Hard
+	};
 }
 function toDockerUlimit(ulimit) {
-  return {
-    Name: ulimit.name,
-    Soft: ulimit.soft,
-    Hard: ulimit.hard
-  };
+	return {
+		Name: ulimit.name,
+		Soft: ulimit.soft,
+		Hard: ulimit.hard
+	};
 }
 function toDockerSandboxOptionName(field) {
-  const optionNames = {
-    Privileged: "privileged",
-    Memory: "memory",
-    MemorySwap: "memorySwap",
-    CpuShares: "cpuShares",
-    CpuQuota: "cpuQuota",
-    CpuPeriod: "cpuPeriod",
-    PidsLimit: "pidsLimit",
-    ReadonlyRootfs: "readonlyRootfs",
-    CapDrop: "capDrop",
-    CapAdd: "capAdd",
-    SecurityOpt: "securityOpt",
-    Ulimits: "ulimits",
-    Tmpfs: "tmpfs"
-  };
-  return optionNames[field] ?? String(field);
+	return {
+		Privileged: "privileged",
+		Memory: "memory",
+		MemorySwap: "memorySwap",
+		CpuShares: "cpuShares",
+		CpuQuota: "cpuQuota",
+		CpuPeriod: "cpuPeriod",
+		PidsLimit: "pidsLimit",
+		ReadonlyRootfs: "readonlyRootfs",
+		CapDrop: "capDrop",
+		CapAdd: "capAdd",
+		SecurityOpt: "securityOpt",
+		Ulimits: "ulimits",
+		Tmpfs: "tmpfs"
+	}[field] ?? String(field);
 }
-
-// src/provider.ts
-var dockerSandboxProvider = {
-  id: "docker",
-  name: "Docker Sandbox",
-  description: "Local container sandbox powered by Docker",
-  configSchema: {
-    type: "object",
-    properties: {
-      image: {
-        type: "string",
-        description: "Docker image to use",
-        default: "node:22-slim"
-      },
-      timeout: {
-        type: "number",
-        description: "Default command timeout in milliseconds",
-        default: 3e5
-      },
-      env: {
-        type: "object",
-        description: "Environment variables",
-        additionalProperties: { type: "string" }
-      },
-      volumes: {
-        type: "object",
-        description: "Host-to-container bind mounts (host path \u2192 container path)",
-        additionalProperties: { type: "string" }
-      },
-      network: {
-        type: "string",
-        description: "Docker network to join"
-      },
-      workingDir: {
-        type: "string",
-        description: "Working directory inside the container",
-        default: "/workspace"
-      },
-      privileged: {
-        type: "boolean",
-        description: "Run in privileged mode",
-        default: false
-      },
-      memory: {
-        type: "number",
-        description: "Memory limit in bytes"
-      },
-      memorySwap: {
-        type: "number",
-        description: "Total memory plus swap in bytes"
-      },
-      cpuShares: {
-        type: "number",
-        description: "CPU shares relative weight"
-      },
-      cpuQuota: {
-        type: "number",
-        description: "CPU quota in microseconds per period"
-      },
-      cpuPeriod: {
-        type: "number",
-        description: "CPU period in microseconds"
-      },
-      pidsLimit: {
-        type: "number",
-        description: "Maximum number of PIDs in the container"
-      },
-      readonlyRootfs: {
-        type: "boolean",
-        description: "Mount the container root filesystem as read-only"
-      },
-      capDrop: {
-        type: "array",
-        description: "Linux capabilities to drop",
-        items: { type: "string" }
-      },
-      capAdd: {
-        type: "array",
-        description: "Linux capabilities to add",
-        items: { type: "string" }
-      },
-      securityOpt: {
-        type: "array",
-        description: "Docker security options",
-        items: { type: "string" }
-      },
-      ulimits: {
-        type: "array",
-        description: "Ulimit entries for Docker HostConfig.Ulimits",
-        items: {
-          type: "object",
-          required: ["name", "soft", "hard"],
-          additionalProperties: false,
-          properties: {
-            name: { type: "string" },
-            soft: { type: "number" },
-            hard: { type: "number" }
-          }
-        }
-      },
-      tmpfs: {
-        type: "object",
-        description: "tmpfs mount paths with options",
-        additionalProperties: { type: "string" }
-      }
-    }
-  },
-  createSandbox: (config) => new DockerSandbox(config)
+//#endregion
+//#region src/provider.ts
+const dockerSandboxProvider = {
+	id: "docker",
+	name: "Docker Sandbox",
+	description: "Local container sandbox powered by Docker",
+	configSchema: {
+		type: "object",
+		properties: {
+			image: {
+				type: "string",
+				description: "Docker image to use",
+				default: "node:22-slim"
+			},
+			timeout: {
+				type: "number",
+				description: "Default command timeout in milliseconds",
+				default: 3e5
+			},
+			env: {
+				type: "object",
+				description: "Environment variables",
+				additionalProperties: { type: "string" }
+			},
+			volumes: {
+				type: "object",
+				description: "Host-to-container bind mounts (host path → container path)",
+				additionalProperties: { type: "string" }
+			},
+			network: {
+				type: "string",
+				description: "Docker network to join"
+			},
+			workingDir: {
+				type: "string",
+				description: "Working directory inside the container",
+				default: "/workspace"
+			},
+			privileged: {
+				type: "boolean",
+				description: "Run in privileged mode",
+				default: false
+			},
+			memory: {
+				type: "number",
+				description: "Memory limit in bytes"
+			},
+			memorySwap: {
+				type: "number",
+				description: "Total memory plus swap in bytes"
+			},
+			cpuShares: {
+				type: "number",
+				description: "CPU shares relative weight"
+			},
+			cpuQuota: {
+				type: "number",
+				description: "CPU quota in microseconds per period"
+			},
+			cpuPeriod: {
+				type: "number",
+				description: "CPU period in microseconds"
+			},
+			pidsLimit: {
+				type: "number",
+				description: "Maximum number of PIDs in the container"
+			},
+			readonlyRootfs: {
+				type: "boolean",
+				description: "Mount the container root filesystem as read-only"
+			},
+			capDrop: {
+				type: "array",
+				description: "Linux capabilities to drop",
+				items: { type: "string" }
+			},
+			capAdd: {
+				type: "array",
+				description: "Linux capabilities to add",
+				items: { type: "string" }
+			},
+			securityOpt: {
+				type: "array",
+				description: "Docker security options",
+				items: { type: "string" }
+			},
+			ulimits: {
+				type: "array",
+				description: "Ulimit entries for Docker HostConfig.Ulimits",
+				items: {
+					type: "object",
+					required: [
+						"name",
+						"soft",
+						"hard"
+					],
+					additionalProperties: false,
+					properties: {
+						name: { type: "string" },
+						soft: { type: "number" },
+						hard: { type: "number" }
+					}
+				}
+			},
+			tmpfs: {
+				type: "object",
+				description: "tmpfs mount paths with options",
+				additionalProperties: { type: "string" }
+			}
+		}
+	},
+	createSandbox: (config) => new DockerSandbox(config)
 };
-
+//#endregion
 exports.DockerProcessManager = DockerProcessManager;
 exports.DockerSandbox = DockerSandbox;
 exports.dockerSandboxProvider = dockerSandboxProvider;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map