@madarco/agentbox 0.13.0 → 0.14.0

package/dist/dist-34RKQ74M.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+import {
+  RUNTIME_ASSETS,
+  Sandbox,
+  Template,
+  candidatesFor,
+  currentE2bBaseFingerprintLive,
+  ensureE2bBaseTemplate,
+  ensureE2bCredentials,
+  ensureE2bEnvLoaded,
+  findStagedCliRuntimeRoot,
+  maskKey,
+  preparedStatePath,
+  readE2bCredStatus,
+  readPreparedState,
+  reloadE2bEnv,
+  resolveApiKey,
+  resolveRuntimeAssets,
+  secretsPath,
+  updatePreparedState,
+  writePreparedState
+} from "./chunk-LDMYHWUS.js";
+import {
+  createCloudProvider,
+  currentCloudBaseFingerprint,
+  listCloudCheckpoints,
+  removeCloudCheckpointDir,
+  renderInnerCommand,
+  resolveCloudCheckpoint,
+  writeCloudCheckpointManifest
+} from "./chunk-TBSIJVSN.js";
+import "./chunk-TCS5HXJX.js";
+import {
+  computeContextSha256,
+  readCliStamp,
+  recordBox
+} from "./chunk-XKH7NTT7.js";
+import "./chunk-G3H2L3O2.js";
+
+// ../../packages/sandbox-e2b/dist/index.js
+import { readFile } from "fs/promises";
+import { copyFile, mkdir, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join, resolve } from "path";
+import { existsSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_BACKOFF = [1e3, 2e3, 4e3];
+var DEFAULT_ATTEMPT_TIMEOUT_MS = 3e4;
+var AttemptTimeoutError = class extends Error {
+  constructor(method, ms) {
+    super(`e2b ${method}: per-attempt timeout after ${String(ms)}ms`);
+    this.name = "AttemptTimeoutError";
+  }
+};
+function statusCodeOf(err) {
+  if (!err || typeof err !== "object") return void 0;
+  for (const key of ["statusCode", "status", "code"]) {
+    const v = err[key];
+    if (typeof v === "number") return v;
+  }
+  const resp = err.response;
+  if (resp && typeof resp.status === "number") return resp.status;
+  return void 0;
+}
+function isRetriable(err, allowAmbiguous) {
+  if (err instanceof AttemptTimeoutError) return allowAmbiguous;
+  const name = err instanceof Error ? err.name : void 0;
+  if (name === "RateLimitError") return true;
+  if (name === "SandboxNotFoundError") return false;
+  const status = statusCodeOf(err);
+  if (status !== void 0) {
+    if (status === 429) return true;
+    if (status >= 500 && status <= 599) return allowAmbiguous;
+    return false;
+  }
+  if (err && typeof err === "object") {
+    const candidates = [err, err.cause];
+    for (const c of candidates) {
+      if (!c || typeof c !== "object") continue;
+      const code = c.code;
+      if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ECONNABORTED" || code === "EAI_AGAIN" || code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "UND_ERR_SOCKET" || code === "UND_ERR_CONNECT_TIMEOUT") {
+        return allowAmbiguous;
+      }
+    }
+  }
+  return false;
+}
+async function withE2bRetry(opts, fn) {
+  const backoff = opts.backoffMs ?? DEFAULT_BACKOFF;
+  const maxAttempts = backoff.length + 1;
+  const timeoutMs = opts.attemptTimeoutMs ?? DEFAULT_ATTEMPT_TIMEOUT_MS;
+  const log = opts.onRetry ?? defaultRetryLog;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await raceTimeout(fn(), timeoutMs, opts.method);
+    } catch (err) {
+      const last = attempt === maxAttempts;
+      if (last || !isRetriable(err, opts.retryOnAmbiguous)) throw err;
+      const delay = backoff[attempt - 1] ?? backoff[backoff.length - 1] ?? 4e3;
+      log(
+        `e2b ${opts.method}: attempt ${String(attempt)} failed (${errorSummary(err)}); retrying in ${String(delay)}ms`
+      );
+      await sleep(delay);
+    }
+  }
+  throw new Error(`withE2bRetry: exhausted attempts for ${opts.method}`);
+}
+function defaultRetryLog(line) {
+  process.stderr.write(`
+[e2b-retry] ${line}
+`);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function raceTimeout(p, ms, method) {
+  let timer;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new AttemptTimeoutError(method, ms)), ms);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function errorSummary(err) {
+  if (err instanceof Error) {
+    const status = statusCodeOf(err);
+    return status !== void 0 ? `${err.name}(${String(status)}): ${truncate(err.message)}` : `${err.name}: ${truncate(err.message)}`;
+  }
+  return truncate(String(err));
+}
+function truncate(s, max = 160) {
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+var DEFAULT_BOX_IMAGE_REF = "agentbox/box:dev";
+var BOX_USER = "vscode";
+var BOX_OWNER = "vscode:vscode";
+var DEFAULT_E2B_DOMAIN = "e2b.app";
+var DEFAULT_TIMEOUT_MS = 45 * 6e4;
+var E2B_WEB_PORT = 8080;
+function shq(s) {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+function bufferToArrayBuffer(b) {
+  const ab = new ArrayBuffer(b.byteLength);
+  new Uint8Array(ab).set(b);
+  return ab;
+}
+function mapState(s) {
+  switch (s) {
+    case "running":
+      return "running";
+    case "paused":
+      return "paused";
+    default:
+      return "missing";
+  }
+}
+function isNotFound(err) {
+  if (!err || typeof err !== "object") return false;
+  const name = err instanceof Error ? err.name : "";
+  if (name === "SandboxNotFoundError" || name === "NotFoundError") return true;
+  const status = err.statusCode ?? err.status;
+  return status === 404;
+}
+function safeMetadataName(name) {
+  return name.replace(/[\u0000-\u001f]/g, "").slice(0, 200);
+}
+var e2bBackend = {
+  name: "e2b",
+  // The cloud scaffold's WebProxy binds whatever port we expose here, and
+  // `agentbox url --kind=web` resolves via `getHost(port)`. 8080 matches the
+  // non-privileged convention vercel uses — `getHost` accepts any port, but
+  // staying on 8080 keeps the in-box ctl flag (AGENTBOX_WEB_PROXY_PORT)
+  // identical across cloud providers.
+  webProxyPort: E2B_WEB_PORT,
+  async provision(req) {
+    const apiKey = resolveApiKey();
+    const log = req.onLog ?? (() => {
+    });
+    if (req.snapshot === void 0) {
+      ensureE2bBaseTemplate();
+    }
+    const template = req.snapshot ?? readPreparedState().base?.templateId;
+    if (!template) {
+      throw new Error(
+        "e2b provision: no template available \u2014 `agentbox prepare --provider e2b` must run first"
+      );
+    }
+    const sb = await withE2bRetry(
+      { method: "provision", retryOnAmbiguous: false, attemptTimeoutMs: 3e5, backoffMs: [] },
+      async () => Sandbox.create({
+        apiKey,
+        template,
+        // Friendly name (so prune can see it) + the 'agentbox' marker so
+        // `list()` can filter out sandboxes provisioned by other tooling.
+        metadata: { agentbox: "true", "agentbox.name": safeMetadataName(req.name), name: safeMetadataName(req.name) },
+        envs: req.env,
+        timeoutMs: req.timeoutMs ?? DEFAULT_TIMEOUT_MS
+      })
+    );
+    log(`e2b: created sandbox ${sb.sandboxId} (template ${template})`);
+    return { sandboxId: sb.sandboxId };
+  },
+  async get(sandboxId) {
+    const apiKey = resolveApiKey();
+    return withE2bRetry({ method: "get", retryOnAmbiguous: true }, async () => {
+      try {
+        await Sandbox.getInfo(sandboxId, { apiKey });
+        return { sandboxId };
+      } catch (err) {
+        if (isNotFound(err)) return null;
+        throw err;
+      }
+    });
+  },
+  async list() {
+    const apiKey = resolveApiKey();
+    return withE2bRetry({ method: "list", retryOnAmbiguous: true }, async () => {
+      const summaries = [];
+      for (const state of ["running", "paused"]) {
+        const paginator = Sandbox.list({ apiKey, query: { state: [state] } });
+        while (paginator.hasNext) {
+          const page = await paginator.nextItems();
+          for (const info of page) {
+            if (info.metadata?.["agentbox"] !== "true") continue;
+            const friendly = info.metadata?.["agentbox.name"] ?? info.metadata?.["name"];
+            const summary = { sandboxId: info.sandboxId, state };
+            if (friendly) summary.name = friendly;
+            const startedAt = info.startedAt;
+            if (startedAt instanceof Date) summary.createdAt = startedAt.toISOString();
+            summaries.push(summary);
+          }
+        }
+      }
+      return summaries;
+    });
+  },
+  // E2B has no separate stop primitive — sandboxes are either running or
+  // paused. start is therefore a connect-and-resume (auto-resume inside
+  // Sandbox.connect handles a paused box transparently).
+  async start(h) {
+    const apiKey = resolveApiKey();
+    await withE2bRetry(
+      { method: "start", retryOnAmbiguous: true, attemptTimeoutMs: 12e4 },
+      async () => {
+        await Sandbox.connect(h.sandboxId, { apiKey });
+      }
+    );
+  },
+  // stop ≡ pause on E2B (the pause IS the cold-storage state).
+  async stop(h) {
+    await this.pause(h);
+  },
+  async pause(h) {
+    const apiKey = resolveApiKey();
+    await withE2bRetry(
+      { method: "pause", retryOnAmbiguous: true, attemptTimeoutMs: 12e4 },
+      async () => {
+        await Sandbox.pause(h.sandboxId, { apiKey });
+      }
+    );
+  },
+  async resume(h) {
+    await this.start(h);
+  },
+  async destroy(h) {
+    const apiKey = resolveApiKey();
+    await withE2bRetry(
+      { method: "destroy", retryOnAmbiguous: true, attemptTimeoutMs: 12e4 },
+      async () => {
+        try {
+          await Sandbox.kill(h.sandboxId, { apiKey });
+        } catch (err) {
+          if (isNotFound(err)) return;
+          throw err;
+        }
+      }
+    );
+  },
+  async state(h) {
+    const apiKey = resolveApiKey();
+    return withE2bRetry({ method: "state", retryOnAmbiguous: true }, async () => {
+      try {
+        const info = await Sandbox.getInfo(h.sandboxId, { apiKey });
+        return mapState(info.state);
+      } catch (err) {
+        if (isNotFound(err)) return "missing";
+        throw err;
+      }
+    });
+  },
+  async exec(h, cmd, opts) {
+    const apiKey = resolveApiKey();
+    const timeoutMs = opts?.attemptTimeoutMs ?? 3e5;
+    return withE2bRetry(
+      {
+        method: "exec",
+        retryOnAmbiguous: opts?.noRetry ? false : true,
+        attemptTimeoutMs: timeoutMs,
+        backoffMs: opts?.noRetry ? [] : void 0
+      },
+      async () => {
+        const sb = await Sandbox.connect(h.sandboxId, { apiKey });
+        const user = opts?.user ?? BOX_USER;
+        try {
+          const r = await sb.commands.run(cmd, {
+            ...opts?.cwd !== void 0 ? { cwd: opts.cwd } : {},
+            ...opts?.env !== void 0 ? { envs: opts.env } : {},
+            user,
+            timeoutMs
+          });
+          return { exitCode: r.exitCode, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+        } catch (err) {
+          if (err instanceof Error && err.name === "CommandExitError") {
+            const ce = err;
+            return { exitCode: ce.exitCode, stdout: ce.stdout ?? "", stderr: ce.stderr ?? "" };
+          }
+          throw err;
+        }
+      }
+    );
+  },
+  async uploadFile(h, localPath, remotePath) {
+    const apiKey = resolveApiKey();
+    await withE2bRetry(
+      { method: "uploadFile", retryOnAmbiguous: true, attemptTimeoutMs: 3e5 },
+      async () => {
+        const data = await readFile(localPath);
+        const sb = await Sandbox.connect(h.sandboxId, { apiKey });
+        await sb.files.write([{ path: remotePath, data: bufferToArrayBuffer(data) }]);
+        try {
+          await sb.commands.run(`sudo -n chown ${BOX_OWNER} ${shq(remotePath)}`, {
+            user: "root",
+            timeoutMs: 1e4
+          });
+        } catch {
+        }
+      }
+    );
+  },
+  async downloadFile(h, remotePath, localPath) {
+    const apiKey = resolveApiKey();
+    await withE2bRetry(
+      { method: "downloadFile", retryOnAmbiguous: true, attemptTimeoutMs: 3e5 },
+      async () => {
+        const sb = await Sandbox.connect(h.sandboxId, { apiKey });
+        const bytes = await sb.files.read(remotePath, { format: "bytes" });
+        const { writeFile } = await import("fs/promises");
+        await writeFile(localPath, Buffer.from(bytes));
+      }
+    );
+  },
+  async listFiles(h, remoteDir) {
+    const apiKey = resolveApiKey();
+    return withE2bRetry({ method: "listFiles", retryOnAmbiguous: true }, async () => {
+      const sb = await Sandbox.connect(h.sandboxId, { apiKey });
+      const entries = await sb.files.list(remoteDir);
+      return entries.map((e) => ({ name: e.name, isDir: e.type === "dir" }));
+    });
+  },
+  async previewUrl(h, port) {
+    const domain = process.env.E2B_DOMAIN ?? DEFAULT_E2B_DOMAIN;
+    return { url: `https://${String(port)}-${h.sandboxId}.${domain}`, token: void 0 };
+  },
+  // Fewer params than the interface's (h, port, expiresInSeconds) is fine —
+  // E2B preview URLs are already public + browser-usable; no per-URL TTL.
+  async signedPreviewUrl(h, port) {
+    return this.previewUrl(h, port);
+  },
+  /**
+   * Probe whether a snapshot (i.e. a template id) is still bootable. E2B's
+   * snapshot ids look like `template-id:tag` or `team-slug/name:tag` — both
+   * accepted by `Template.exists(name)`. Returns false on any lookup failure
+   * (treated by the cloud-provider as "gone" so it falls back to a from-base
+   * boot rather than 410ing the user).
+   */
+  async snapshotExists(snapshotName2) {
+    const apiKey = resolveApiKey();
+    return withE2bRetry({ method: "snapshotExists", retryOnAmbiguous: true }, async () => {
+      try {
+        return await Template.exists(snapshotName2, { apiKey });
+      } catch {
+        return false;
+      }
+    });
+  }
+};
+var TEMPLATE_NAME = "agentbox-base:latest";
+var DEFAULT_TAG = "latest";
+var DEFAULT_CPU = 2;
+var DEFAULT_MEMORY_MB = 4096;
+async function prepareE2b(opts = {}) {
+  await ensureE2bCredentials();
+  const apiKey = resolveApiKey();
+  const log = opts.onLog ?? (() => {
+  });
+  const progress = (s) => log(`prepare-e2b: ${s}`);
+  const assets = resolveRuntimeAssets({
+    cliRuntimeRoot: opts.cliRuntimeRoot ?? findStagedCliRuntimeRoot(),
+    repoRoot: opts.repoRoot
+  });
+  const contextSha = await computeContextSha256(
+    assets.map((a) => ({ rel: a.name, abs: a.localPath }))
+  );
+  const existing = readPreparedState();
+  if (!opts.force && existing.base) {
+    if (existing.base.contextSha256 === contextSha) {
+      const stillThere = await templateExists(existing.base.templateId, apiKey);
+      if (stillThere) {
+        progress(
+          `template ${existing.base.templateId} already exists (fingerprint ${contextSha.slice(0, 12)} matches); skipping (pass --force to rebuild)`
+        );
+        return { snapshotName: existing.base.templateId };
+      }
+      progress(`recorded template ${existing.base.templateId} is gone on E2B; rebuilding`);
+    } else {
+      progress(
+        `build context changed (was ${existing.base.contextSha256?.slice(0, 12) ?? "<none>"}, now ${contextSha.slice(0, 12)}); rebuilding`
+      );
+    }
+  }
+  const contextDir = await mkdtemp(join(tmpdir(), "agentbox-e2b-build-"));
+  try {
+    progress(`staging build context at ${contextDir}`);
+    await stageAssetsInto(contextDir, assets);
+    progress("assembling template build (fromBaseImage + asset copy + runCmd)");
+    const template = Template({ fileContextPath: contextDir }).fromBaseImage();
+    for (const a of assets) {
+      progress(`  copy ${a.name} -> ${a.remotePath}`);
+      template.copy(a.name, a.remotePath, {
+        forceUpload: true,
+        mode: a.remoteMode,
+        user: "root"
+      });
+    }
+    template.runCmd("bash /tmp/agentbox-build-template.sh 2>&1", { user: "root" });
+    const finalTemplate = template.setReadyCmd(
+      "test -x /usr/local/bin/agentbox-ctl"
+    );
+    const cpuCount = opts.cpuCount ?? DEFAULT_CPU;
+    const memoryMB = opts.memoryMB ?? DEFAULT_MEMORY_MB;
+    progress(
+      `running Template.build('${TEMPLATE_NAME}', { cpuCount: ${String(cpuCount)}, memoryMB: ${String(memoryMB)} })`
+    );
+    const info = await Template.build(finalTemplate, TEMPLATE_NAME, {
+      apiKey,
+      cpuCount,
+      memoryMB,
+      onBuildLogs: (entry) => {
+        log(`[build] ${formatBuildLog(entry)}`);
+      }
+    });
+    progress(`template built: id=${info.templateId} build=${info.buildId} name=${info.name}`);
+    const tag = info.tags?.[0] ?? DEFAULT_TAG;
+    const cliStamp = readCliStamp();
+    const taggedId = `${info.templateId}:${tag}`;
+    writePreparedState({
+      schema: 1,
+      base: {
+        templateId: taggedId,
+        // info.name is the full `name:tag` pair Template.build() was called
+        // with (e.g. `agentbox-base:latest`). Earlier code re-appended `:${tag}`
+        // and produced `agentbox-base:latest:latest` in the status display.
+        templateName: info.name,
+        contextSha256: contextSha,
+        cliVersion: cliStamp.cliVersion,
+        cliCommit: cliStamp.cliCommit,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    progress(`wrote ${preparedStatePath()}`);
+    progress(`prepare complete \u2014 base template ${taggedId}`);
+    return { snapshotName: taggedId };
+  } finally {
+    await rm(contextDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function stageAssetsInto(contextDir, assets) {
+  for (const a of assets) {
+    const dest = resolve(contextDir, a.name);
+    await mkdir(dirname(dest), { recursive: true });
+    await copyFile(a.localPath, dest);
+  }
+}
+async function templateExists(name, apiKey) {
+  try {
+    return await Template.exists(name, { apiKey });
+  } catch {
+    return false;
+  }
+}
+function formatBuildLog(entry) {
+  const raw = typeof entry.message === "string" ? entry.message : entry.toString();
+  const cleaned = raw.replace(/\r?\n+$/, "");
+  return cleaned.length > 200 ? cleaned.slice(0, 200) + "\u2026" : cleaned;
+}
+var prepareE2bProvider = (req) => prepareE2b({
+  name: req.name,
+  hostWorkspace: req.hostWorkspace ?? process.cwd(),
+  force: req.force,
+  onLog: req.onLog
+});
+var SELF = dirname2(fileURLToPath(import.meta.url));
+function resolveAttachHelperPath() {
+  const candidates = [
+    // dev: dist/index.js sibling
+    resolve2(SELF, "attach-helper.cjs"),
+    // dev: src compiled to dist/, while index.ts is in src/
+    resolve2(SELF, "..", "dist", "attach-helper.cjs"),
+    // staged CLI: apps/cli/runtime/e2b/attach-helper.cjs
+    resolve2(SELF, "..", "runtime", "e2b", "attach-helper.cjs"),
+    resolve2(SELF, "..", "..", "runtime", "e2b", "attach-helper.cjs")
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  return candidates[0];
+}
+async function buildE2bAttach(box, kind, opts) {
+  const sandboxId = box.cloud?.sandboxId;
+  if (!sandboxId) {
+    throw new Error(`e2b box ${box.name} has no sandboxId \u2014 record is malformed`);
+  }
+  const helper = resolveAttachHelperPath();
+  if (!existsSync(helper)) {
+    throw new Error(
+      `e2b attach helper not found at ${helper} \u2014 rebuild the CLI (\`pnpm -w build\`) so packages/sandbox-e2b/dist/attach-helper.cjs is generated.`
+    );
+  }
+  const apiKey = resolveApiKey();
+  const inner = renderInnerCommand(kind, opts);
+  const argv = [
+    process.execPath,
+    helper,
+    "--sandbox-id",
+    sandboxId,
+    "--user",
+    "vscode"
+  ];
+  return {
+    argv,
+    env: {
+      E2B_API_KEY: apiKey,
+      AGENTBOX_E2B_INNER_CMD: inner
+    }
+  };
+}
+var BACKEND_NAME = "e2b";
+var cloudProvider = createCloudProvider(e2bBackend, {
+  // E2B applies resources at the template level (Template.build({ cpuCount,
+  // memoryMB }) — `prepare` sets these). The numbers below are advisory
+  // metadata for BoxRecord stats / the dashboard pane; per-create overrides
+  // aren't honored by the SDK.
+  defaultResources: { cpu: 2, memory: 4, disk: 8 },
+  launchDockerd: false
+});
+async function createE2bSnapshot(sandboxId, name) {
+  const apiKey = resolveApiKey();
+  return withE2bRetry(
+    { method: "createSnapshot", retryOnAmbiguous: false, attemptTimeoutMs: 9e5, backoffMs: [] },
+    async () => {
+      const info = await Sandbox.createSnapshot(sandboxId, { apiKey, name });
+      return info.snapshotId;
+    }
+  );
+}
+async function deleteE2bSnapshot(snapshotId) {
+  const apiKey = resolveApiKey();
+  await withE2bRetry({ method: "deleteSnapshot", retryOnAmbiguous: true }, async () => {
+    try {
+      await Sandbox.deleteSnapshot(snapshotId, { apiKey });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (/not.?found|404/i.test(msg)) return;
+      throw err;
+    }
+  });
+}
+function snapshotName(boxName, checkpointName) {
+  const sanitize = (s) => s.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "");
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").replace("Z", "");
+  return `agentbox-${sanitize(boxName)}-${sanitize(checkpointName)}-${sanitize(ts)}`;
+}
+var e2bCheckpoint = {
+  async create(box, name) {
+    if (!box.projectRoot) {
+      throw new Error(
+        "cloud checkpoint requires the box to have a project root (run `agentbox checkpoint` from inside the project)"
+      );
+    }
+    if (!box.cloud?.sandboxId) {
+      throw new Error(`e2b box ${box.name} has no sandboxId \u2014 record is malformed`);
+    }
+    const e2bSnapName = snapshotName(box.name, name);
+    const snapshotId = await createE2bSnapshot(box.cloud.sandboxId, e2bSnapName);
+    try {
+      await recordBox({ ...box, cloud: { ...box.cloud, lastState: "paused" } });
+    } catch {
+    }
+    const info = await writeCloudCheckpointManifest(box.projectRoot, BACKEND_NAME, name, {
+      snapshotName: snapshotId,
+      sourceBoxId: box.id,
+      sourceBoxName: box.name,
+      baseProvider: BACKEND_NAME,
+      baseFingerprint: currentCloudBaseFingerprint(BACKEND_NAME),
+      cliVersion: readCliStamp().cliVersion
+    });
+    return { ref: info.name };
+  },
+  async list(projectRoot) {
+    const entries = await listCloudCheckpoints(projectRoot, BACKEND_NAME);
+    return entries.map((e) => ({ ref: e.name, createdAt: e.manifest.createdAt }));
+  },
+  async remove(projectRoot, ref) {
+    const entry = await resolveCloudCheckpoint(projectRoot, BACKEND_NAME, ref);
+    if (!entry) return;
+    try {
+      await deleteE2bSnapshot(entry.manifest.snapshotName);
+    } catch {
+    }
+    await removeCloudCheckpointDir(projectRoot, BACKEND_NAME, ref);
+  }
+};
+var e2bProvider = {
+  ...cloudProvider,
+  prepare: prepareE2bProvider,
+  buildAttach: buildE2bAttach,
+  checkpoint: e2bCheckpoint,
+  baseFingerprint: () => currentE2bBaseFingerprintLive()
+};
+export {
+  DEFAULT_BOX_IMAGE_REF,
+  RUNTIME_ASSETS,
+  buildE2bAttach,
+  candidatesFor,
+  currentE2bBaseFingerprintLive,
+  e2bBackend,
+  e2bProvider,
+  ensureE2bBaseTemplate,
+  ensureE2bCredentials,
+  ensureE2bEnvLoaded,
+  findStagedCliRuntimeRoot,
+  maskKey,
+  prepareE2b,
+  prepareE2bProvider,
+  preparedStatePath,
+  readE2bCredStatus,
+  readPreparedState,
+  reloadE2bEnv,
+  resolveRuntimeAssets,
+  secretsPath,
+  updatePreparedState,
+  writePreparedState
+};
+//# sourceMappingURL=dist-34RKQ74M.js.map