newcraw 1.0.2 → 1.0.3

package/dist/chunk-4A6CDBDH.js

@@ -0,0 +1,822 @@
+import { createRequire as __newcrawCreateRequire } from "node:module";
+const require = __newcrawCreateRequire(import.meta.url);
+import {
+  debug,
+  init_debugLogger
+} from "./chunk-GZ4BEVMZ.js";
+import {
+  init_log,
+  logError
+} from "./chunk-BMJ5XGFR.js";
+import {
+  __esm,
+  __export
+} from "./chunk-D4OZACS2.js";
+
+// src/services/sandbox/types.ts
+var DEFAULT_SANDBOX_CONFIG;
+var init_types = __esm({
+  "src/services/sandbox/types.ts"() {
+    DEFAULT_SANDBOX_CONFIG = {
+      engine: "podman",
+      fallbackEngine: "docker",
+      poolSize: 2,
+      poolIdleTimeoutMs: 3e5,
+      defaultTimeoutMs: 6e4,
+      defaultMemoryLimitMb: 512,
+      defaultCpuLimit: 1,
+      networkEnabled: false
+    };
+  }
+});
+
+// src/services/sandbox/runtimeImages.ts
+function getRuntimeImage(runtime) {
+  return RUNTIME_IMAGES[runtime];
+}
+function getImageFullName(runtime) {
+  return RUNTIME_IMAGES[runtime].fullName;
+}
+function getAllRuntimeImages() {
+  return Object.values(RUNTIME_IMAGES);
+}
+function resolveImage(runtime, customImage) {
+  if (customImage) return customImage;
+  return getImageFullName(runtime);
+}
+var RUNTIME_IMAGES;
+var init_runtimeImages = __esm({
+  "src/services/sandbox/runtimeImages.ts"() {
+    RUNTIME_IMAGES = {
+      python: {
+        runtime: "python",
+        image: "python",
+        tag: "3.11-alpine",
+        fullName: "python:3.11-alpine",
+        preInstallCommands: ["pip install --no-cache-dir --upgrade pip"]
+      },
+      node: {
+        runtime: "node",
+        image: "node",
+        tag: "20-alpine",
+        fullName: "node:20-alpine"
+      },
+      bash: {
+        runtime: "bash",
+        image: "alpine",
+        tag: "3.19",
+        fullName: "alpine:3.19",
+        preInstallCommands: ["apk add --no-cache bash curl jq"]
+      },
+      custom: {
+        runtime: "custom",
+        image: "alpine",
+        tag: "3.19",
+        fullName: "alpine:3.19"
+      }
+    };
+  }
+});
+
+// src/services/sandbox/podmanEngine.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import which from "which";
+function whichSync(bin) {
+  try {
+    return which.sync(bin, { nothrow: true }) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function detectContainerEngine() {
+  for (const engine of ["podman", "docker"]) {
+    const binary = whichSync(engine);
+    if (!binary) continue;
+    try {
+      const version = await execSimple([binary, "--version"]);
+      const rootless = engine === "podman" ? await checkPodmanRootless(binary) : false;
+      detectedEngine = engine;
+      detectedBinary = binary;
+      return {
+        name: engine,
+        available: true,
+        rootless,
+        version: version.trim()
+      };
+    } catch {
+      continue;
+    }
+  }
+  detectedEngine = "none";
+  detectedBinary = null;
+  return { name: "none", available: false, rootless: false };
+}
+async function checkPodmanRootless(binary) {
+  try {
+    const info = await execSimple([binary, "info", "--format", "{{.Host.Security.Rootless}}"]);
+    return info.trim().toLowerCase() === "true";
+  } catch {
+    return process.getuid?.() !== 0;
+  }
+}
+function getEngineBinary() {
+  if (detectedBinary) return detectedBinary;
+  const podman = whichSync("podman");
+  if (podman) {
+    detectedEngine = "podman";
+    detectedBinary = podman;
+    return podman;
+  }
+  const docker = whichSync("docker");
+  if (docker) {
+    detectedEngine = "docker";
+    detectedBinary = docker;
+    return docker;
+  }
+  throw new Error(
+    "No container engine found. Install Podman (preferred) or Docker."
+  );
+}
+function getEngineType() {
+  if (detectedEngine) return detectedEngine;
+  getEngineBinary();
+  return detectedEngine;
+}
+function execSimple(cmd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd[0], cmd.slice(1), {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(`Command failed (${code}): ${stderr}`));
+    });
+    child.on("error", reject);
+  });
+}
+function buildRunArgs(config) {
+  const binary = getEngineBinary();
+  const image = resolveImage(config.runtime, config.image);
+  const name = `kode-sandbox-${randomUUID().slice(0, 8)}`;
+  const args = [
+    binary,
+    "run",
+    "--name",
+    name,
+    "--detach",
+    "--init"
+  ];
+  if (!config.networkEnabled) {
+    args.push("--network", "none");
+  }
+  if (config.memoryLimitMb) {
+    args.push("--memory", `${config.memoryLimitMb}m`);
+  }
+  if (config.cpuLimit) {
+    args.push("--cpus", String(config.cpuLimit));
+  }
+  if (config.workDir) {
+    args.push("--workdir", config.workDir);
+  }
+  for (const mount of config.mountPaths ?? []) {
+    const opt = mount.readOnly ? `${mount.hostPath}:${mount.containerPath}:ro` : `${mount.hostPath}:${mount.containerPath}`;
+    args.push("-v", opt);
+  }
+  for (const [key, value] of Object.entries(config.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  args.push(image, "sleep", "infinity");
+  return args;
+}
+async function createContainer(config) {
+  const args = buildRunArgs(config);
+  const binary = args[0];
+  const runArgs = args.slice(1);
+  const output = await execSimple([binary, ...runArgs]);
+  const containerId = output.trim().slice(0, 12);
+  const name = runArgs[runArgs.indexOf("--name") + 1];
+  return {
+    id: containerId,
+    name,
+    image: resolveImage(config.runtime, config.image),
+    status: "ready",
+    runtime: config.runtime,
+    createdAt: Date.now(),
+    lastUsedAt: Date.now()
+  };
+}
+async function execInContainer(containerId, options) {
+  const binary = getEngineBinary();
+  const startTime = Date.now();
+  const args = [binary, "exec"];
+  if (options.cwd) {
+    args.push("--workdir", options.cwd);
+  }
+  for (const [key, value] of Object.entries(options.env ?? {})) {
+    args.push("-e", `${key}=${value}`);
+  }
+  args.push(containerId, ...options.command);
+  return new Promise((resolve, reject) => {
+    const child = spawn(args[0], args.slice(1), {
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let timer;
+    if (options.timeoutMs) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, options.timeoutMs);
+    }
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    if (options.stdin) {
+      child.stdin?.write(options.stdin);
+      child.stdin?.end();
+    } else {
+      child.stdin?.end();
+    }
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? (timedOut ? 137 : 1),
+        durationMs: Date.now() - startTime,
+        timedOut
+      });
+    });
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function removeContainer(containerId) {
+  const binary = getEngineBinary();
+  try {
+    await execSimple([binary, "rm", "-f", containerId]);
+  } catch (err) {
+    logError(err);
+  }
+}
+async function stopContainer(containerId) {
+  const binary = getEngineBinary();
+  try {
+    await execSimple([binary, "stop", "-t", "3", containerId]);
+  } catch (err) {
+    logError(err);
+  }
+}
+async function getContainerStatus(containerId) {
+  const binary = getEngineBinary();
+  try {
+    const output = await execSimple([
+      binary,
+      "inspect",
+      "--format",
+      "{{.State.Status}}",
+      containerId
+    ]);
+    const status = output.trim().toLowerCase();
+    switch (status) {
+      case "running":
+        return "running";
+      case "created":
+        return "creating";
+      case "exited":
+      case "stopped":
+        return "stopped";
+      default:
+        return "error";
+    }
+  } catch {
+    return "destroyed";
+  }
+}
+async function pullImage(image) {
+  const binary = getEngineBinary();
+  await execSimple([binary, "pull", image]);
+}
+async function imageExists(image) {
+  const binary = getEngineBinary();
+  try {
+    await execSimple([binary, "image", "inspect", image]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var detectedEngine, detectedBinary;
+var init_podmanEngine = __esm({
+  "src/services/sandbox/podmanEngine.ts"() {
+    init_log();
+    init_runtimeImages();
+    detectedEngine = null;
+    detectedBinary = null;
+  }
+});
+
+// src/services/sandbox/containerLifecycle.ts
+function getContainerLifecycleManager() {
+  if (!globalLifecycleManager) {
+    globalLifecycleManager = new ContainerLifecycleManager();
+  }
+  return globalLifecycleManager;
+}
+var ContainerLifecycleManager, globalLifecycleManager;
+var init_containerLifecycle = __esm({
+  "src/services/sandbox/containerLifecycle.ts"() {
+    init_log();
+    init_podmanEngine();
+    init_runtimeImages();
+    init_types();
+    ContainerLifecycleManager = class {
+      activeContainers = /* @__PURE__ */ new Map();
+      async ensureImage(runtime, customImage) {
+        const image = resolveImage(runtime, customImage);
+        const exists = await imageExists(image);
+        if (!exists) {
+          await pullImage(image);
+        }
+      }
+      async spawn(config) {
+        const mergedConfig = {
+          timeoutMs: DEFAULT_SANDBOX_CONFIG.defaultTimeoutMs,
+          memoryLimitMb: DEFAULT_SANDBOX_CONFIG.defaultMemoryLimitMb,
+          cpuLimit: DEFAULT_SANDBOX_CONFIG.defaultCpuLimit,
+          networkEnabled: DEFAULT_SANDBOX_CONFIG.networkEnabled,
+          ...config
+        };
+        await this.ensureImage(mergedConfig.runtime, mergedConfig.image);
+        const info = await createContainer(mergedConfig);
+        this.activeContainers.set(info.id, info);
+        return info;
+      }
+      async exec(containerId, options) {
+        const info = this.activeContainers.get(containerId);
+        if (info) {
+          info.lastUsedAt = Date.now();
+          info.status = "running";
+        }
+        const result = await execInContainer(containerId, {
+          timeoutMs: DEFAULT_SANDBOX_CONFIG.defaultTimeoutMs,
+          ...options
+        });
+        if (info) {
+          info.status = "ready";
+        }
+        return result;
+      }
+      async destroy(containerId) {
+        try {
+          await stopContainer(containerId);
+          await removeContainer(containerId);
+        } catch (err) {
+          logError(err);
+        } finally {
+          this.activeContainers.delete(containerId);
+        }
+      }
+      async destroyAll() {
+        const ids = Array.from(this.activeContainers.keys());
+        await Promise.allSettled(ids.map((id) => this.destroy(id)));
+      }
+      getActive() {
+        return Array.from(this.activeContainers.values());
+      }
+      getContainer(containerId) {
+        return this.activeContainers.get(containerId);
+      }
+      get activeCount() {
+        return this.activeContainers.size;
+      }
+    };
+    globalLifecycleManager = null;
+  }
+});
+
+// src/services/sandbox/containerPool.ts
+var ContainerPool;
+var init_containerPool = __esm({
+  "src/services/sandbox/containerPool.ts"() {
+    init_log();
+    init_types();
+    ContainerPool = class {
+      pool = /* @__PURE__ */ new Map();
+      lifecycle;
+      config;
+      constructor(lifecycle, config = {}) {
+        this.lifecycle = lifecycle;
+        this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
+      }
+      async warmup(runtime, count) {
+        const n = count ?? this.config.poolSize;
+        const existing = this.getIdleByRuntime(runtime);
+        const needed = Math.max(0, n - existing.length);
+        const promises = [];
+        for (let i = 0; i < needed; i++) {
+          promises.push(this.spawnPoolEntry(runtime));
+        }
+        await Promise.allSettled(promises);
+      }
+      async acquire(runtime, config) {
+        const idle = this.getIdleByRuntime(runtime);
+        if (idle.length > 0) {
+          const entry = idle[0];
+          entry.inUse = true;
+          if (entry.idleTimer) {
+            clearTimeout(entry.idleTimer);
+            entry.idleTimer = void 0;
+          }
+          entry.container.lastUsedAt = Date.now();
+          return entry.container;
+        }
+        const containerConfig = {
+          runtime,
+          networkEnabled: this.config.networkEnabled,
+          memoryLimitMb: this.config.defaultMemoryLimitMb,
+          cpuLimit: this.config.defaultCpuLimit,
+          timeoutMs: this.config.defaultTimeoutMs,
+          ...config
+        };
+        const info = await this.lifecycle.spawn(containerConfig);
+        this.pool.set(info.id, {
+          container: info,
+          runtime,
+          inUse: true
+        });
+        return info;
+      }
+      release(containerId) {
+        const entry = this.pool.get(containerId);
+        if (!entry) return;
+        entry.inUse = false;
+        entry.container.lastUsedAt = Date.now();
+        const idleCount = this.getIdleByRuntime(entry.runtime).length;
+        if (idleCount > this.config.poolSize) {
+          void this.evict(containerId);
+          return;
+        }
+        entry.idleTimer = setTimeout(() => {
+          void this.evict(containerId);
+        }, this.config.poolIdleTimeoutMs);
+      }
+      async exec(containerId, options) {
+        return this.lifecycle.exec(containerId, options);
+      }
+      async evict(containerId) {
+        const entry = this.pool.get(containerId);
+        if (!entry) return;
+        if (entry.inUse) return;
+        if (entry.idleTimer) {
+          clearTimeout(entry.idleTimer);
+        }
+        this.pool.delete(containerId);
+        try {
+          await this.lifecycle.destroy(containerId);
+        } catch (err) {
+          logError(err);
+        }
+      }
+      async spawnPoolEntry(runtime) {
+        try {
+          const info = await this.lifecycle.spawn({
+            runtime,
+            networkEnabled: this.config.networkEnabled,
+            memoryLimitMb: this.config.defaultMemoryLimitMb,
+            cpuLimit: this.config.defaultCpuLimit,
+            timeoutMs: this.config.defaultTimeoutMs
+          });
+          const entry = {
+            container: info,
+            runtime,
+            inUse: false
+          };
+          entry.idleTimer = setTimeout(() => {
+            void this.evict(info.id);
+          }, this.config.poolIdleTimeoutMs);
+          this.pool.set(info.id, entry);
+        } catch (err) {
+          logError(err);
+        }
+      }
+      getIdleByRuntime(runtime) {
+        return Array.from(this.pool.values()).filter(
+          (e) => e.runtime === runtime && !e.inUse
+        );
+      }
+      async shutdown() {
+        for (const entry of this.pool.values()) {
+          if (entry.idleTimer) clearTimeout(entry.idleTimer);
+        }
+        const ids = Array.from(this.pool.keys());
+        await Promise.allSettled(ids.map((id) => this.lifecycle.destroy(id)));
+        this.pool.clear();
+      }
+      get stats() {
+        const entries = Array.from(this.pool.values());
+        return {
+          total: entries.length,
+          idle: entries.filter((e) => !e.inUse).length,
+          inUse: entries.filter((e) => e.inUse).length,
+          byRuntime: Object.fromEntries(
+            ["python", "node", "bash"].map((rt) => [
+              rt,
+              {
+                total: entries.filter((e) => e.runtime === rt).length,
+                idle: entries.filter((e) => e.runtime === rt && !e.inUse).length,
+                inUse: entries.filter((e) => e.runtime === rt && e.inUse).length
+              }
+            ])
+          )
+        };
+      }
+    };
+  }
+});
+
+// src/services/sandbox/skillExecutor.ts
+async function executeSkillInSandbox(request) {
+  const pool = getSandboxPool();
+  if (!pool) {
+    debug.warn("SKILL_SANDBOX_NOT_AVAILABLE", {
+      skillDir: request.skillDir,
+      runtime: request.runtime
+    });
+    throw new Error(
+      "Sandbox pool not initialized. Ensure container engine (Podman/Docker) is available."
+    );
+  }
+  const containerConfig = {
+    runtime: request.runtime,
+    workDir: "/workspace",
+    mountPaths: [
+      {
+        hostPath: request.skillDir,
+        containerPath: "/workspace/skill",
+        readOnly: true
+      },
+      ...request.workDir ? [{
+        hostPath: request.workDir,
+        containerPath: "/workspace/project",
+        readOnly: false
+      }] : []
+    ],
+    env: request.env,
+    timeoutMs: request.timeoutMs ?? 12e4
+  };
+  const container = await pool.acquire(request.runtime, containerConfig);
+  try {
+    if (request.dependencies) {
+      const installResult = await installDependencies(
+        container.id,
+        request.runtime,
+        request.dependencies,
+        request.skillDir
+      );
+      if (installResult.exitCode !== 0) {
+        debug.warn("SKILL_DEPENDENCY_INSTALL_FAILED", {
+          stderr: installResult.stderr.slice(0, 500)
+        });
+      }
+    }
+    const command = buildExecCommand(request);
+    const result = await pool.exec(container.id, {
+      command,
+      cwd: "/workspace",
+      env: request.env,
+      timeoutMs: request.timeoutMs ?? 12e4
+    });
+    const outputFiles = await collectOutputFiles(pool, container.id);
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode,
+      durationMs: result.durationMs,
+      outputFiles
+    };
+  } catch (err) {
+    logError(err);
+    throw err;
+  } finally {
+    pool.release(container.id);
+  }
+}
+async function installDependencies(containerId, runtime, dependenciesFile, skillDir) {
+  const lifecycle = getContainerLifecycleManager();
+  const depsPath = `/workspace/skill/${dependenciesFile}`;
+  let command;
+  switch (runtime) {
+    case "python":
+      command = ["pip", "install", "--no-cache-dir", "-r", depsPath];
+      break;
+    case "node":
+      command = ["npm", "install", "--prefix", "/workspace/skill"];
+      break;
+    default:
+      return { stdout: "", stderr: "", exitCode: 0, durationMs: 0, timedOut: false };
+  }
+  return lifecycle.exec(containerId, {
+    command,
+    cwd: "/workspace",
+    timeoutMs: 6e4
+  });
+}
+function buildExecCommand(request) {
+  const scriptPath = `/workspace/skill/${request.executionScript}`;
+  switch (request.runtime) {
+    case "python":
+      return ["python", scriptPath, ...request.args ? [request.args] : []];
+    case "node":
+      return ["node", scriptPath, ...request.args ? [request.args] : []];
+    case "bash":
+      return ["bash", scriptPath, ...request.args ? [request.args] : []];
+    default:
+      return ["sh", scriptPath, ...request.args ? [request.args] : []];
+  }
+}
+async function collectOutputFiles(pool, containerId) {
+  try {
+    const lsResult = await pool.exec(containerId, {
+      command: ["find", "/workspace/project", "-maxdepth", "2", "-type", "f", "-newer", "/workspace/skill", "-name", "*.*"],
+      cwd: "/workspace",
+      timeoutMs: 5e3
+    });
+    if (lsResult.exitCode !== 0 || !lsResult.stdout.trim()) return [];
+    return lsResult.stdout.trim().split("\n").filter((f) => {
+      const ext = f.slice(f.lastIndexOf(".")).toLowerCase();
+      return OUTPUT_EXTENSIONS.has(ext);
+    });
+  } catch {
+    return [];
+  }
+}
+function canExecuteInSandbox(skill) {
+  return !!(skill.runtime && skill.executionScript);
+}
+var OUTPUT_EXTENSIONS;
+var init_skillExecutor = __esm({
+  "src/services/sandbox/skillExecutor.ts"() {
+    init_log();
+    init_debugLogger();
+    init_sandbox();
+    init_containerLifecycle();
+    OUTPUT_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".webp",
+      ".html",
+      ".htm",
+      ".csv",
+      ".json",
+      ".xml",
+      ".md",
+      ".txt",
+      ".py",
+      ".js",
+      ".ts"
+    ]);
+  }
+});
+
+// src/services/sandbox/index.ts
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  ContainerLifecycleManager: () => ContainerLifecycleManager,
+  ContainerPool: () => ContainerPool,
+  DEFAULT_SANDBOX_CONFIG: () => DEFAULT_SANDBOX_CONFIG,
+  canExecuteInSandbox: () => canExecuteInSandbox,
+  createContainer: () => createContainer,
+  detectContainerEngine: () => detectContainerEngine,
+  execInContainer: () => execInContainer,
+  executeSkillInSandbox: () => executeSkillInSandbox,
+  getAllRuntimeImages: () => getAllRuntimeImages,
+  getContainerLifecycleManager: () => getContainerLifecycleManager,
+  getContainerStatus: () => getContainerStatus,
+  getEngineBinary: () => getEngineBinary,
+  getEngineType: () => getEngineType,
+  getImageFullName: () => getImageFullName,
+  getRuntimeImage: () => getRuntimeImage,
+  getSandboxCapabilities: () => getSandboxCapabilities,
+  getSandboxPool: () => getSandboxPool,
+  imageExists: () => imageExists,
+  initSandboxPool: () => initSandboxPool,
+  pullImage: () => pullImage,
+  removeContainer: () => removeContainer,
+  resolveImage: () => resolveImage,
+  shutdownSandboxPool: () => shutdownSandboxPool,
+  stopContainer: () => stopContainer,
+  tryInitSandboxPool: () => tryInitSandboxPool
+});
+async function initSandboxPool(config) {
+  const capabilities = await detectContainerEngine();
+  detectedCapabilities = capabilities;
+  if (!capabilities.available) {
+    throw new Error(
+      `No container engine available. Install Podman (rootless preferred) or Docker.
+Podman: https://podman.io/docs/installation
+Docker: https://docs.docker.com/get-docker/`
+    );
+  }
+  const lifecycle = getContainerLifecycleManager();
+  globalPool = new ContainerPool(lifecycle, config);
+  return globalPool;
+}
+async function tryInitSandboxPool(config) {
+  try {
+    const capabilities = await detectContainerEngine();
+    detectedCapabilities = capabilities;
+    if (!capabilities.available) {
+      return { pool: null, capabilities };
+    }
+    const lifecycle = getContainerLifecycleManager();
+    globalPool = new ContainerPool(lifecycle, config);
+    return { pool: globalPool, capabilities };
+  } catch {
+    return {
+      pool: null,
+      capabilities: { name: "none", available: false, rootless: false }
+    };
+  }
+}
+function getSandboxPool() {
+  return globalPool;
+}
+function getSandboxCapabilities() {
+  return detectedCapabilities;
+}
+async function shutdownSandboxPool() {
+  if (globalPool) {
+    await globalPool.shutdown();
+    globalPool = null;
+  }
+  const lifecycle = getContainerLifecycleManager();
+  await lifecycle.destroyAll();
+}
+var globalPool, detectedCapabilities;
+var init_sandbox = __esm({
+  "src/services/sandbox/index.ts"() {
+    init_types();
+    init_podmanEngine();
+    init_runtimeImages();
+    init_containerLifecycle();
+    init_containerPool();
+    init_skillExecutor();
+    init_containerPool();
+    init_containerLifecycle();
+    init_podmanEngine();
+    globalPool = null;
+    detectedCapabilities = null;
+  }
+});
+
+export {
+  DEFAULT_SANDBOX_CONFIG,
+  getRuntimeImage,
+  getImageFullName,
+  getAllRuntimeImages,
+  resolveImage,
+  detectContainerEngine,
+  getEngineBinary,
+  getEngineType,
+  createContainer,
+  execInContainer,
+  removeContainer,
+  stopContainer,
+  getContainerStatus,
+  pullImage,
+  imageExists,
+  ContainerLifecycleManager,
+  getContainerLifecycleManager,
+  ContainerPool,
+  executeSkillInSandbox,
+  canExecuteInSandbox,
+  initSandboxPool,
+  tryInitSandboxPool,
+  getSandboxPool,
+  getSandboxCapabilities,
+  shutdownSandboxPool,
+  sandbox_exports,
+  init_sandbox
+};