@agen-ai/sandbox-docker 0.0.0-stage → 0.4.4

package/dist/engine/response.js

@@ -0,0 +1,109 @@
+import { DockerEngineTransportError } from "./contracts.js";
+function invalid(message) {
+  return new DockerEngineTransportError("invalid_response", message);
+}
+async function waitReadable(response) {
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      response.removeListener("readable", ready);
+      response.removeListener("end", ready);
+      response.removeListener("error", failed);
+      response.removeListener("close", closed);
+    };
+    const ready = () => {
+      cleanup();
+      resolve();
+    };
+    const failed = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const closed = () => {
+      cleanup();
+      response.readableEnded ? resolve() : reject(invalid("Engine response closed before EOF."));
+    };
+    response.once("readable", ready);
+    response.once("end", ready);
+    response.once("error", failed);
+    response.once("close", closed);
+    if (response.readableEnded || response.readableLength) ready();
+    else if (response.destroyed) closed();
+  });
+}
+class DockerResponseBody {
+  constructor(response, chunkBytes, signal, interrupt) {
+    this.response = response;
+    this.chunkBytes = chunkBytes;
+    this.signal = signal;
+    this.interrupt = interrupt;
+  }
+  active = true;
+  entered = false;
+  drained = false;
+  pending;
+  failure;
+  bytes = 0n;
+  body = { [Symbol.asyncIterator]: () => {
+    if (!this.active || this.entered) throw invalid("Engine response body is single-use and callback-scoped.");
+    this.entered = true;
+    return { next: () => this.next(), return: async () => {
+      this.active = false;
+      if (!this.drained) this.interrupt(invalid("Engine response body was abandoned."));
+      await this.pending?.catch(() => {
+      });
+      return { done: true, value: void 0 };
+    } };
+  } };
+  next() {
+    if (!this.active || this.pending) {
+      const error = invalid(this.pending ? "Concurrent Engine response pulls are forbidden." : "Engine response body is retired.");
+      this.failure ??= { error };
+      const rejected = Promise.reject(error);
+      void rejected.catch(() => {
+      });
+      return rejected;
+    }
+    const actual = Promise.resolve().then(async () => {
+      try {
+        for (; ; ) {
+          this.signal.throwIfAborted();
+          const available = this.response.readableLength;
+          const chunk = this.response.read(available ? Math.min(this.chunkBytes, available) : this.chunkBytes);
+          if (!this.active) throw invalid("Engine callback returned with an active body pull.");
+          if (chunk !== null) {
+            if (!(chunk instanceof Uint8Array) || chunk.length > this.chunkBytes) throw invalid("Engine response chunks exceed the selected byte buffer.");
+            this.bytes += BigInt(chunk.length);
+            return { done: false, value: chunk };
+          }
+          if (this.response.readableEnded) {
+            if (!this.response.complete) throw invalid("Engine response HTTP framing is incomplete.");
+            this.drained = true;
+            return { done: true, value: void 0 };
+          }
+          await waitReadable(this.response);
+        }
+      } catch (error) {
+        this.failure ??= { error };
+        throw error;
+      } finally {
+        this.pending = void 0;
+      }
+    });
+    this.pending = actual;
+    void actual.catch(() => {
+    });
+    return actual;
+  }
+  async retire() {
+    const entered = this.pending;
+    this.active = false;
+    if (!this.drained || entered) this.interrupt(this.failure ? this.failure.error : invalid("Engine response callback must drain and join its body."));
+    await entered?.catch(() => {
+    });
+    if (this.failure) throw this.failure.error;
+    if (!this.drained || entered) throw invalid("Engine response callback did not drain and join its body.");
+  }
+}
+export {
+  DockerResponseBody
+};

package/dist/engine/stream.d.ts

@@ -0,0 +1,3 @@
+import type { DockerEngineStreamOptions, DockerEngineStreamResponse, DockerEngineStreamResult } from './contracts.js';
+export declare function streamEngine<Value>(socketPath: string, method: 'GET' | 'HEAD' | 'PUT', path: string, options: DockerEngineStreamOptions, consume: (response: DockerEngineStreamResponse) => Promise<Value>): Promise<DockerEngineStreamResult<Value>>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/engine/stream.js

@@ -0,0 +1,134 @@
+import { request as httpRequest } from "node:http";
+import { DockerEngineTransportError, validateEngineRequest } from "./contracts.js";
+import { DockerResponseBody } from "./response.js";
+import { upload } from "./upload.js";
+async function streamEngine(socketPath, method, path, options, consume) {
+  const connectTimeoutMs = options.connectTimeoutMs ?? 3e4;
+  const headerTimeoutMs = options.headerTimeoutMs ?? 3e4;
+  validateEngineRequest(path, { timeoutMs: connectTimeoutMs, maxResponseBytes: 0 });
+  validateEngineRequest(path, { timeoutMs: headerTimeoutMs, maxResponseBytes: 0 });
+  if (!Number.isSafeInteger(options.chunkBytes) || options.chunkBytes < 512 || options.chunkBytes > 65536) throw new TypeError("Engine chunkBytes must be within 512..65536.");
+  if (method !== "PUT" && options.body !== void 0) throw new TypeError("Only PUT transfers accept a request body.");
+  if (options.signal?.aborted) throw new DockerEngineTransportError("aborted", "Engine transfer aborted before dispatch.", { cause: options.signal.reason });
+  const controller = new AbortController();
+  const ready = Promise.withResolvers();
+  const closed = Promise.withResolvers();
+  const socketClosed = Promise.withResolvers();
+  let response;
+  let responseBody;
+  let socket;
+  let failure;
+  let headerTimer;
+  let result;
+  let retirementError;
+  let uploadedBytes = 0n;
+  const request = httpRequest({
+    socketPath,
+    method,
+    path,
+    agent: false,
+    maxHeaderSize: 16384,
+    headers: { connection: "close", ...options.contentType ? { "content-type": options.contentType } : {} }
+  });
+  const fail = (error, origin) => {
+    if (!failure || failure.origin === "retirement" && origin === "callback") failure = { error, origin };
+    controller.abort(error);
+    ready.reject(error);
+    response?.destroy();
+    request.destroy();
+  };
+  const onAbort = () => fail(new DockerEngineTransportError("aborted", "Engine transfer aborted.", { cause: options.signal?.reason }), "request");
+  request.on("error", (cause) => {
+    const malformed = "code" in cause && typeof cause.code === "string" && cause.code.startsWith("HPE_");
+    fail(new DockerEngineTransportError(malformed ? "invalid_response" : "connection", "Engine transfer connection failed.", { cause }), "request");
+  });
+  request.once("socket", (acquired) => {
+    socket = acquired;
+    acquired.once("close", () => socketClosed.resolve());
+    if (acquired.readableHighWaterMark > 65536 || acquired.writableHighWaterMark > 65536) {
+      fail(new DockerEngineTransportError("invalid_response", "Engine socket exceeds the bounded native buffer profile."), "request");
+    }
+    if (acquired.connecting) acquired.once("connect", () => clearTimeout(connectTimer));
+    else clearTimeout(connectTimer);
+  });
+  request.once("finish", () => {
+    if (!response && !failure) headerTimer = setTimeout(() => fail(new DockerEngineTransportError("deadline", "Engine response-header deadline exceeded."), "request"), headerTimeoutMs);
+  });
+  request.once("response", (incoming) => {
+    response = incoming;
+    clearTimeout(headerTimer);
+    incoming.on("error", (cause) => {
+      if (!controller.signal.aborted) fail(new DockerEngineTransportError("invalid_response", "Engine response stream failed.", { cause }), "request");
+    });
+    incoming.once("aborted", () => {
+      if (!controller.signal.aborted) fail(new DockerEngineTransportError("invalid_response", "Engine response was truncated."), "request");
+    });
+    if (incoming.readableHighWaterMark > 65536) fail(new DockerEngineTransportError("invalid_response", "Engine response exceeds the bounded native buffer profile."), "request");
+    ready.resolve(incoming);
+  });
+  request.once("upgrade", (_incoming, upgraded) => {
+    upgraded.destroy();
+    fail(new DockerEngineTransportError("invalid_response", "Unexpected Engine HTTP upgrade."), "request");
+  });
+  request.once("close", () => {
+    if (!failure && (!response || !request.writableFinished)) fail(new DockerEngineTransportError("connection", "Engine connection closed before transfer dispatch finished."), "request");
+    closed.resolve();
+  });
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const connectTimer = setTimeout(() => fail(new DockerEngineTransportError("deadline", "Engine connection deadline exceeded."), "request"), connectTimeoutMs);
+  if (options.signal?.aborted) onAbort();
+  const writer = upload(request, options.body, controller.signal, options.chunkBytes).then((bytes) => {
+    uploadedBytes = bytes;
+  }, (error) => {
+    fail(error, "writer");
+    throw error;
+  });
+  void writer.catch(() => {
+  });
+  try {
+    const incoming = await ready.promise;
+    responseBody = new DockerResponseBody(incoming, options.chunkBytes, controller.signal, (error) => {
+      retirementError ??= error;
+      fail(error, "retirement");
+    });
+    if (incoming.statusCode === void 0) throw new DockerEngineTransportError("invalid_response", "Engine response omitted its status.");
+    try {
+      result = { value: await consume({
+        statusCode: incoming.statusCode,
+        headers: incoming.headers,
+        rawHeaders: incoming.rawHeaders,
+        body: responseBody.body,
+        signal: controller.signal
+      }) };
+    } catch (error) {
+      fail(error, "callback");
+    }
+    try {
+      await responseBody.retire();
+    } catch (error) {
+      if (!failure) fail(error, "retirement");
+    }
+    await writer;
+  } catch (error) {
+    if (!failure) fail(error, "request");
+  } finally {
+    const writerOutcome = await Promise.allSettled([writer]);
+    response?.destroy();
+    request.destroy();
+    await closed.promise;
+    if (socket) await socketClosed.promise;
+    clearTimeout(connectTimer);
+    clearTimeout(headerTimer);
+    options.signal?.removeEventListener("abort", onAbort);
+    const outcome = writerOutcome[0];
+    if (outcome.status === "rejected" && failure && outcome.reason !== failure.error && outcome.reason !== retirementError) {
+      failure = { error: new AggregateError([failure.error, outcome.reason], "Engine transfer and request producer cleanup both failed."), origin: failure.origin };
+    }
+  }
+  if (failure) throw failure.error;
+  if (!result) throw new DockerEngineTransportError("invalid_response", "Engine transfer did not settle its response.");
+  return { value: result.value, uploadedBytes, downloadedBytes: responseBody?.bytes ?? 0n };
+}
+export {
+  streamEngine
+};

package/dist/engine/upgrade.d.ts

@@ -0,0 +1,9 @@
+import type { Duplex } from 'node:stream';
+import { type DockerEngineRequestOptions } from './contracts.js';
+export interface DockerEngineAttachment {
+    readonly stream: Duplex;
+    readonly head: Uint8Array;
+    readonly closed: Promise<void>;
+}
+export declare function upgradeEngineConnection(socketPath: string, path: string, options: DockerEngineRequestOptions): Promise<DockerEngineAttachment>;
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/engine/upgrade.js

@@ -0,0 +1,164 @@
+import { request as httpRequest } from "node:http";
+import { performance } from "node:perf_hooks";
+import { DockerEngineTransportError, validateEngineRequest } from "./contracts.js";
+async function upgradeEngineConnection(socketPath, path, options) {
+  validateEngineRequest(path, options);
+  const { timeoutMs, maxResponseBytes, signal } = options;
+  if (options.body === void 0 || options.contentType !== "application/json") {
+    throw new TypeError("Engine upgrade requires an explicit JSON request body");
+  }
+  if (signal?.aborted) throw new DockerEngineTransportError("aborted", "Engine upgrade aborted");
+  const deadline = performance.now() + timeoutMs;
+  const body = Buffer.from(options.body);
+  if (performance.now() >= deadline) throw new DockerEngineTransportError("deadline", "Engine upgrade deadline exceeded");
+  return new Promise((resolve, reject) => {
+    let response;
+    let socket;
+    let requestClosed = false;
+    let responseClosed = false;
+    let socketClosed = false;
+    let outcome;
+    let settled = false;
+    let receivedBytes = 0;
+    const closed = Promise.withResolvers();
+    void closed.promise.catch(() => {
+    });
+    let socketError;
+    const request = httpRequest({
+      socketPath,
+      method: "POST",
+      path,
+      agent: false,
+      maxHeaderSize: 16384,
+      headers: {
+        connection: "Upgrade",
+        upgrade: "tcp",
+        "content-type": "application/json",
+        "content-length": body.byteLength
+      }
+    });
+    const clearHandshake = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const settleFailureIfClosed = () => {
+      if (settled || outcome?.kind !== "failure" || !requestClosed || response !== void 0 && !responseClosed || socket !== void 0 && !socketClosed) return;
+      settled = true;
+      clearHandshake();
+      reject(outcome.error);
+    };
+    const fail = (error) => {
+      if (outcome !== void 0) return;
+      outcome = { kind: "failure", error };
+      response?.destroy();
+      socket?.destroy();
+      request.destroy();
+      settleFailureIfClosed();
+    };
+    const deadlineExpired = () => {
+      if (performance.now() < deadline) return false;
+      fail(new DockerEngineTransportError("deadline", "Engine upgrade deadline exceeded"));
+      return true;
+    };
+    const onAbort = () => fail(new DockerEngineTransportError("aborted", "Engine upgrade aborted"));
+    const timer = setTimeout(() => {
+      fail(new DockerEngineTransportError("deadline", "Engine upgrade deadline exceeded"));
+    }, Math.max(1, Math.ceil(deadline - performance.now())));
+    request.once("socket", (connection) => {
+      socket = connection;
+      connection.on("error", (cause) => {
+        socketError ??= new DockerEngineTransportError("connection", "Engine upgraded connection failed", { cause });
+        fail(socketError);
+      });
+      connection.once("close", () => {
+        socketClosed = true;
+        if (socketError === void 0) closed.resolve();
+        else closed.reject(socketError);
+        if (outcome === void 0) fail(new DockerEngineTransportError("connection", "Engine connection closed before upgrade"));
+        settleFailureIfClosed();
+      });
+      if (outcome?.kind === "failure") connection.destroy();
+    });
+    request.on("error", (cause) => {
+      const malformedResponse = "code" in cause && typeof cause.code === "string" && cause.code.startsWith("HPE_");
+      fail(new DockerEngineTransportError(
+        malformedResponse ? "invalid_response" : "connection",
+        malformedResponse ? "Engine upgrade has invalid HTTP framing" : "Engine upgrade connection failed",
+        { cause }
+      ));
+    });
+    request.once("close", () => {
+      requestClosed = true;
+      if (outcome === void 0 && response === void 0) {
+        fail(new DockerEngineTransportError("connection", "Engine connection closed before upgrade"));
+      }
+      settleFailureIfClosed();
+    });
+    request.once("upgrade", (message, connection, head) => {
+      if (outcome !== void 0) {
+        connection.destroy();
+        return;
+      }
+      if (deadlineExpired()) return;
+      const connectionTokens = message.headers.connection?.split(",").map((token) => token.trim().toLowerCase());
+      if (message.statusCode !== 101 || !connectionTokens?.includes("upgrade") || message.headers.upgrade?.toLowerCase() !== "tcp") {
+        fail(new DockerEngineTransportError("invalid_response", "Engine upgrade requires HTTP 101 with the tcp protocol"));
+        return;
+      }
+      if (connection.destroyed) {
+        fail(new DockerEngineTransportError("connection", "Engine upgraded connection is already closed"));
+        return;
+      }
+      if (head.byteLength > 65536) {
+        fail(new DockerEngineTransportError("response_limit", "Engine upgrade head exceeds its byte limit"));
+        return;
+      }
+      connection.pause();
+      outcome = { kind: "handed_off" };
+      settled = true;
+      clearHandshake();
+      resolve({ stream: connection, head: Buffer.from(head), closed: closed.promise });
+    });
+    request.once("response", (message) => {
+      response = message;
+      message.on("error", (cause) => {
+        fail(new DockerEngineTransportError("invalid_response", "Engine upgrade response stream failed", { cause }));
+      });
+      message.once("aborted", () => {
+        fail(new DockerEngineTransportError("invalid_response", "Engine upgrade response was truncated"));
+      });
+      message.once("close", () => {
+        responseClosed = true;
+        if (outcome === void 0) fail(new DockerEngineTransportError("invalid_response", "Engine upgrade response closed before completion"));
+        settleFailureIfClosed();
+      });
+      message.on("data", (chunk) => {
+        if (outcome !== void 0 || deadlineExpired()) return;
+        if (chunk.byteLength > maxResponseBytes - receivedBytes) {
+          fail(new DockerEngineTransportError("response_limit", "Engine upgrade response exceeds its byte limit"));
+          return;
+        }
+        receivedBytes += chunk.byteLength;
+      });
+      message.once("end", () => {
+        if (outcome !== void 0 || deadlineExpired()) return;
+        fail(new DockerEngineTransportError("invalid_response", `Engine upgrade requires HTTP 101, received ${message.statusCode}`));
+      });
+      if (outcome !== void 0) {
+        message.destroy();
+        return;
+      }
+      if (deadlineExpired()) return;
+      const contentLength = message.headers["content-length"];
+      if (contentLength !== void 0 && Number(contentLength) > maxResponseBytes) {
+        fail(new DockerEngineTransportError("response_limit", "Engine upgrade response exceeds its byte limit"));
+      }
+    });
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    if (outcome === void 0) request.end(body);
+  });
+}
+export {
+  upgradeEngineConnection
+};

package/dist/engine/upload.d.ts

@@ -0,0 +1,4 @@
+import type { ClientRequest } from 'node:http';
+import type { DockerEngineStreamOptions } from './contracts.js';
+export declare function upload(request: ClientRequest, input: DockerEngineStreamOptions['body'], signal: AbortSignal, chunkBytes: number): Promise<bigint>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/engine/upload.js

@@ -0,0 +1,48 @@
+import { DockerEngineTransportError } from "./contracts.js";
+async function upload(request, input, signal, chunkBytes) {
+  let bytes = 0n;
+  if (input !== void 0) {
+    const source = typeof input === "function" ? input(signal) : input;
+    const iterator = Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+    let done = false;
+    let primary;
+    try {
+      for (; ; ) {
+        signal.throwIfAborted();
+        const item = await iterator.next();
+        signal.throwIfAborted();
+        if (item.done) {
+          done = true;
+          break;
+        }
+        const chunk = item.value;
+        if (!(chunk instanceof Uint8Array) || chunk.length > chunkBytes) throw new DockerEngineTransportError("invalid_response", "Engine upload chunks exceed the selected byte buffer.");
+        if (chunk.length === 0) continue;
+        await new Promise((resolve, reject) => {
+          request.write(chunk, (error) => error ? reject(error) : resolve());
+        });
+        bytes += BigInt(chunk.length);
+      }
+    } catch (error) {
+      primary = { error };
+    } finally {
+      if (!done) {
+        try {
+          await iterator.return?.();
+        } catch (error) {
+          if (primary) throw new AggregateError([primary.error, error], "Engine upload and producer cleanup both failed.");
+          throw error;
+        }
+      }
+    }
+    if (primary) throw primary.error;
+  }
+  signal.throwIfAborted();
+  await new Promise((resolve, reject) => {
+    request.end((error) => error ? reject(error) : resolve());
+  });
+  return bytes;
+}
+export {
+  upload
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { SandboxBackend } from '@agen-ai/sandbox';
+import type { DockerSandboxBackendOptions } from './policy/config.js';
+export type { DockerSandboxBackendOptions } from './policy/config.js';
+export type { DockerSandboxProfile } from './policy/profiles.js';
+export type { DockerSandboxDataset } from './datasets/types.js';
+export declare function createDockerSandboxBackend(options: DockerSandboxBackendOptions): SandboxBackend;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,30 @@
+import { createSandboxBackend } from "@agen-ai/sandbox/backend";
+import { DockerEngine } from "./engine/client.js";
+import { parseDockerConfig, DOCKER_BACKEND_ID } from "./policy/config.js";
+import { dockerBackendRevision } from "./policy/profiles.js";
+import { DockerApi } from "./resources/api.js";
+import { DockerResourceOwner } from "./resources/owner.js";
+import { reconcileDocker } from "./recovery/reconcile.js";
+function createDockerSandboxBackend(options) {
+  const config = parseDockerConfig(options);
+  const api = new DockerApi(new DockerEngine(config.endpoint.slice(7)), 3e4);
+  return createSandboxBackend({
+    support: {
+      backendId: DOCKER_BACKEND_ID,
+      backendRevision: dockerBackendRevision(config.profile),
+      networkModes: ["isolated", "outbound"],
+      workspaceDiskQuota: false,
+      networkAllowlist: false,
+      independentProcessTermination: false
+    },
+    reserve(request) {
+      return new DockerResourceOwner(api, config, request);
+    },
+    reconcile(record, operation) {
+      return reconcileDocker(api, config, record, operation);
+    }
+  });
+}
+export {
+  createDockerSandboxBackend
+};

package/dist/policy/config.d.ts

@@ -0,0 +1,22 @@
+import type { DockerSandboxProfile } from './profiles.js';
+import type { DockerSandboxDataset } from '../datasets/types.js';
+export interface DockerSandboxBackendOptions {
+    readonly profile?: DockerSandboxProfile;
+    readonly endpoint: string;
+    readonly namespace: string;
+    readonly imageDigest: string;
+    readonly spillDirectory: string;
+    readonly user: Readonly<{
+        uid: number;
+        gid: number;
+    }>;
+    readonly datasets?: readonly DockerSandboxDataset[];
+}
+export interface DockerSandboxConfig extends DockerSandboxBackendOptions {
+    readonly profile: DockerSandboxProfile;
+    readonly datasets: readonly DockerSandboxDataset[];
+}
+export declare function parseDockerConfig(input: unknown): DockerSandboxConfig;
+export declare const DOCKER_BACKEND_ID = "agenai-docker";
+export declare const DOCKER_API = "/v1.52";
+//# sourceMappingURL=config.d.ts.map

package/dist/policy/config.js

@@ -0,0 +1,63 @@
+import { z } from "zod/v4";
+import { normalizeZodValidationError } from "@agen-ai/validation/zod";
+import { SandboxValidationError } from "@agen-ai/sandbox";
+import { parseSandboxSpillDirectory } from "@agen-ai/sandbox/node";
+import { DOCKER_SANDBOX_PROFILES } from "./profiles.js";
+import { datasetsSchema, MAX_DATASET_ATTACHMENTS, normalizeDatasets } from "../datasets/configuration.js";
+const userSchema = z.strictObject({ uid: z.number().int().min(1).max(262143), gid: z.number().int().min(1).max(262143) });
+const configSchema = z.strictObject({
+  profile: z.enum(DOCKER_SANDBOX_PROFILES).default("linux-x64"),
+  endpoint: z.string().min(9).max(512).regex(/^unix:\/\/\/[a-zA-Z0-9_.\-/]+$/u).refine((value) => !value.slice(7).split("/").some((part) => part === "." || part === "..") && !value.includes("//", 7), "Expected a canonical absolute Unix socket endpoint"),
+  namespace: z.string().regex(/^[a-z][a-z0-9-]{0,62}$/u),
+  imageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+  spillDirectory: z.string(),
+  user: userSchema,
+  datasets: datasetsSchema.default([])
+});
+function plainData(value, depth = 0) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    if (depth > 1 || Object.getPrototypeOf(value) !== Array.prototype || value.length > MAX_DATASET_ATTACHMENTS || Reflect.ownKeys(value).length !== value.length + 1) {
+      throw new SandboxValidationError([{ code: "invalid_input", path: [], message: "Docker datasets require a bounded dense data array" }]);
+    }
+    const result2 = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const entry = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!entry || !("value" in entry) || !entry.enumerable) {
+        throw new SandboxValidationError([{ code: "invalid_input", path: [], message: "Docker dataset entries must be enumerable data properties" }]);
+      }
+      result2.push(plainData(entry.value, depth + 1));
+    }
+    return result2;
+  }
+  if (depth > 2 || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new SandboxValidationError([{ code: "invalid_input", path: [], message: "Docker configuration requires plain data objects" }]);
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key of Reflect.ownKeys(value)) {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || key === "__proto__" || property === void 0 || !("value" in property) || !property.enumerable) {
+      throw new SandboxValidationError([{ code: "invalid_input", path: [], message: "Docker configuration cannot contain accessors, symbols or hidden fields" }]);
+    }
+    result[key] = plainData(property.value, depth + 1);
+  }
+  return result;
+}
+function parseDockerConfig(input) {
+  const captured = plainData(input);
+  const result = configSchema.safeParse(captured);
+  if (!result.success) throw new SandboxValidationError(normalizeZodValidationError(configSchema, result.error, captured));
+  return Object.freeze({
+    ...result.data,
+    spillDirectory: parseSandboxSpillDirectory(result.data.spillDirectory),
+    user: Object.freeze(result.data.user),
+    datasets: normalizeDatasets(result.data.datasets)
+  });
+}
+const DOCKER_BACKEND_ID = "agenai-docker";
+const DOCKER_API = "/v1.52";
+export {
+  DOCKER_API,
+  DOCKER_BACKEND_ID,
+  parseDockerConfig
+};

package/dist/policy/container.d.ts

@@ -0,0 +1,70 @@
+import type { SandboxPolicy, SandboxRecoveryRecord } from '@agen-ai/sandbox';
+import type { DockerSandboxConfig } from './config.js';
+import type { ContainerInspection } from '../resources/inspect.js';
+export declare const KEEPER: string[];
+export declare const DOCKER_ENVIRONMENT: readonly string[];
+export declare function tmpfs(policy: SandboxPolicy, config: DockerSandboxConfig): Readonly<Record<string, string>>;
+export declare function containerBody(config: DockerSandboxConfig, record: SandboxRecoveryRecord, policy: SandboxPolicy, role: 'compute' | 'export', storageId: string, networkId: string | undefined): {
+    Image: string;
+    User: string;
+    WorkingDir: string;
+    Entrypoint: string[];
+    Cmd: string[];
+    Env: readonly string[];
+    Tty: boolean;
+    OpenStdin: boolean;
+    AttachStdin: boolean;
+    AttachStdout: boolean;
+    AttachStderr: boolean;
+    NetworkDisabled: boolean;
+    Healthcheck: {
+        Test: string[];
+    };
+    Labels: Readonly<Record<string, string>>;
+    HostConfig: {
+        ReadonlyRootfs: boolean;
+        CapDrop: string[];
+        CapAdd: never[];
+        SecurityOpt: string[];
+        Privileged: boolean;
+        PublishAllPorts: boolean;
+        PortBindings: {};
+        Devices: never[];
+        DeviceRequests: never[];
+        Binds: never[];
+        PidMode: string;
+        IpcMode: string;
+        CgroupnsMode: string;
+        UsernsMode: string;
+        NetworkMode: string | undefined;
+        NanoCpus: number;
+        Memory: number;
+        MemorySwap: number;
+        PidsLimit: number;
+        RestartPolicy: {
+            Name: string;
+            MaximumRetryCount: number;
+        };
+        AutoRemove: boolean;
+        Tmpfs: Readonly<Record<string, string>>;
+        Mounts: ({
+            ImageOptions?: {
+                Subpath: string;
+            } | undefined;
+            Type: "image";
+            Source: string;
+            Target: string;
+            ReadOnly: true;
+        } | {
+            Type: "volume";
+            Source: string;
+            Target: string;
+            ReadOnly: boolean;
+            VolumeOptions: {
+                NoCopy: true;
+            };
+        })[];
+    };
+};
+export declare function verifyContainer(container: ContainerInspection, config: DockerSandboxConfig, policy: SandboxPolicy, role: 'compute' | 'export', storageId: string, networkId: string | undefined, started: boolean): void;
+//# sourceMappingURL=container.d.ts.map