@sentry/junior 0.57.0 → 0.58.0

package/dist/{chunk-D3G3YOU4.js → chunk-ITOW4DED.js}

@@ -2,7 +2,7 @@ import {
   getPluginForSkillPath,
   getPluginSkillRoots,
   logWarn
-} from "./chunk-TTUY467K.js";
+} from "./chunk-H652GMDH.js";
 import {
   skillRoots
 } from "./chunk-5LUISFEY.js";

package/dist/chunk-QDGD5WVN.js

@@ -0,0 +1,708 @@
+import {
+  getStateAdapter,
+  toOptionalTrimmed
+} from "./chunk-FKEKRBUB.js";
+import {
+  getPluginRuntimeDependencies,
+  getPluginRuntimePostinstall,
+  withSpan
+} from "./chunk-H652GMDH.js";
+
+// src/chat/sandbox/runtime-dependency-snapshots.ts
+import { createHash } from "crypto";
+import { Sandbox } from "@vercel/sandbox";
+
+// src/chat/sandbox/noninteractive-command.ts
+var NON_INTERACTIVE_ENV = {
+  CI: "1",
+  TERM: "dumb",
+  NO_COLOR: "1",
+  PAGER: "cat",
+  GIT_PAGER: "cat",
+  GH_PROMPT_DISABLED: "1",
+  GH_NO_UPDATE_NOTIFIER: "1",
+  GH_NO_EXTENSION_UPDATE_NOTIFIER: "1",
+  GH_SPINNER_DISABLED: "1",
+  GIT_TERMINAL_PROMPT: "0",
+  GCM_INTERACTIVE: "never",
+  DEBIAN_FRONTEND: "noninteractive",
+  // Git credential isolation: prevent git from sending its own auth so the
+  // sandbox egress proxy's header transforms are the sole credential source.
+  GIT_ASKPASS: "/bin/true",
+  GIT_CONFIG_NOSYSTEM: "1",
+  GIT_CONFIG_COUNT: "2",
+  GIT_CONFIG_KEY_0: "credential.helper",
+  GIT_CONFIG_VALUE_0: "",
+  GIT_CONFIG_KEY_1: "http.emptyAuth",
+  GIT_CONFIG_VALUE_1: "true"
+};
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildEnvExports(options) {
+  const lines = [];
+  if (options.pathPrefix) {
+    lines.push(`export PATH="${options.pathPrefix}"`);
+  }
+  for (const [key, value] of Object.entries(NON_INTERACTIVE_ENV)) {
+    lines.push(`export ${key}=${shellQuote(value)}`);
+  }
+  for (const [key, value] of Object.entries(options.env ?? {})) {
+    lines.push(`export ${key}=${shellQuote(value)}`);
+  }
+  return lines;
+}
+function toCommandScript(input) {
+  return [shellQuote(input.cmd), ...(input.args ?? []).map(shellQuote)].join(
+    " "
+  );
+}
+function buildNonInteractiveShellScript(script, options = {}) {
+  return [...buildEnvExports(options), "exec </dev/null", script].join(" && ");
+}
+function buildNonInteractiveCommand(input) {
+  return {
+    cmd: "bash",
+    args: [
+      input.login ? "-lc" : "-c",
+      buildNonInteractiveShellScript(toCommandScript(input), {
+        env: input.env,
+        pathPrefix: input.pathPrefix
+      })
+    ]
+  };
+}
+async function runNonInteractiveCommand(sandbox, input) {
+  const command = {
+    ...buildNonInteractiveCommand(input),
+    ...input.cwd ? { cwd: input.cwd } : {},
+    ...input.sudo !== void 0 ? { sudo: input.sudo } : {}
+  };
+  return await sandbox.runCommand(command);
+}
+
+// src/chat/sandbox/credentials.ts
+function getVercelSandboxCredentials() {
+  const token = toOptionalTrimmed(process.env.VERCEL_TOKEN);
+  const teamId = toOptionalTrimmed(process.env.VERCEL_TEAM_ID);
+  const projectId = toOptionalTrimmed(process.env.VERCEL_PROJECT_ID);
+  if (token && teamId && projectId) {
+    return { token, teamId, projectId };
+  }
+  return void 0;
+}
+
+// src/chat/sandbox/workspace.ts
+function createSandboxInstance(sandbox) {
+  return {
+    sandboxId: sandbox.name,
+    get sandboxEgressId() {
+      return sandbox.currentSession().sessionId;
+    },
+    fs: sandbox.fs,
+    extendTimeout(duration) {
+      return sandbox.extendTimeout(duration);
+    },
+    mkDir(path) {
+      return sandbox.mkDir(path);
+    },
+    readFileToBuffer(input) {
+      return sandbox.readFileToBuffer(input);
+    },
+    runCommand(input) {
+      return sandbox.runCommand(input);
+    },
+    async snapshot() {
+      const snapshot = await sandbox.snapshot();
+      return { snapshotId: snapshot.snapshotId };
+    },
+    stop() {
+      return sandbox.stop();
+    },
+    update(params) {
+      return sandbox.update(params);
+    },
+    writeFiles(files) {
+      return sandbox.writeFiles(files);
+    }
+  };
+}
+
+// src/chat/sandbox/paths.ts
+function normalizeWorkspaceRoot(input) {
+  const candidate = (input ?? "").trim();
+  if (!candidate) {
+    return "/vercel/sandbox";
+  }
+  const normalized = candidate.replace(/\/+$/, "");
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+var SANDBOX_WORKSPACE_ROOT = normalizeWorkspaceRoot(
+  process.env.VERCEL_SANDBOX_WORKSPACE_DIR
+);
+var SANDBOX_SKILLS_ROOT = `${SANDBOX_WORKSPACE_ROOT}/skills`;
+var SANDBOX_DATA_ROOT = `${SANDBOX_WORKSPACE_ROOT}/data`;
+function sandboxSkillDir(skillName) {
+  return `${SANDBOX_SKILLS_ROOT}/${skillName}`;
+}
+function sandboxSkillFile(skillName) {
+  return `${sandboxSkillDir(skillName)}/SKILL.md`;
+}
+
+// src/chat/sandbox/runtime-dependency-snapshots.ts
+var SNAPSHOT_CACHE_PREFIX = "junior:sandbox_snapshot_profile";
+var SNAPSHOT_LOCK_PREFIX = "junior:sandbox_snapshot_lock";
+var SNAPSHOT_PROFILE_VERSION = 1;
+var SNAPSHOT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var SNAPSHOT_BUILD_LOCK_TTL_MS = 10 * 60 * 1e3;
+var SNAPSHOT_WAIT_FOR_LOCK_MS = SNAPSHOT_BUILD_LOCK_TTL_MS + 30 * 1e3;
+var DEFAULT_FLOATING_DEP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function profileCacheKey(profileHash) {
+  return `${SNAPSHOT_CACHE_PREFIX}:${profileHash}`;
+}
+function profileLockKey(profileHash) {
+  return `${SNAPSHOT_LOCK_PREFIX}:${profileHash}`;
+}
+function isExactNpmVersion(version) {
+  return /^\d+\.\d+\.\d+(?:[-+][a-z0-9.]+)?$/i.test(version.trim());
+}
+function hasFloatingSelector(dep) {
+  return dep.type === "npm" && !isExactNpmVersion(dep.version);
+}
+function parseFloatingDepMaxAgeMs() {
+  const raw = process.env.SANDBOX_SNAPSHOT_FLOATING_MAX_AGE_MS;
+  if (!raw?.trim()) {
+    return DEFAULT_FLOATING_DEP_MAX_AGE_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_FLOATING_DEP_MAX_AGE_MS;
+  }
+  return parsed;
+}
+function buildDependencyProfile(runtime) {
+  const dependencies = getPluginRuntimeDependencies();
+  const postinstall = getPluginRuntimePostinstall();
+  if (dependencies.length === 0 && postinstall.length === 0) {
+    return null;
+  }
+  const rebuildEpoch = process.env.SANDBOX_SNAPSHOT_REBUILD_EPOCH?.trim() ?? "";
+  const hasFloatingVersions = dependencies.some((dep) => hasFloatingSelector(dep)) || postinstall.length > 0;
+  const hashInput = JSON.stringify({
+    version: SNAPSHOT_PROFILE_VERSION,
+    runtime,
+    rebuildEpoch,
+    dependencies,
+    postinstall
+  });
+  const profileHash = createHash("sha256").update(hashInput).digest("hex");
+  return {
+    profileHash,
+    dependencyCount: dependencies.length,
+    hasFloatingVersions,
+    dependencies,
+    postinstall
+  };
+}
+function getRuntimeDependencyProfileHash(runtime) {
+  return buildDependencyProfile(runtime)?.profileHash;
+}
+function shouldRebuildCachedSnapshot(profile, cached) {
+  if (!profile.hasFloatingVersions) {
+    return false;
+  }
+  const maxAgeMs = parseFloatingDepMaxAgeMs();
+  if (maxAgeMs === 0) {
+    return true;
+  }
+  return Date.now() - cached.createdAtMs > maxAgeMs;
+}
+async function getCachedSnapshot(profileHash) {
+  try {
+    const state = getStateAdapter();
+    await state.connect();
+    const raw = await state.get(profileCacheKey(profileHash));
+    if (typeof raw !== "string") {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || typeof parsed.profileHash !== "string" || typeof parsed.snapshotId !== "string" || typeof parsed.runtime !== "string" || typeof parsed.createdAtMs !== "number" || typeof parsed.dependencyCount !== "number") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function setCachedSnapshot(entry) {
+  const state = getStateAdapter();
+  await state.connect();
+  await state.set(
+    profileCacheKey(entry.profileHash),
+    JSON.stringify(entry),
+    SNAPSHOT_CACHE_TTL_MS
+  );
+}
+async function withSnapshotSpan(name, op, attributes, callback) {
+  return await withSpan(name, op, {}, callback, attributes);
+}
+async function runOrThrow(sandbox, params, label) {
+  const result = await runNonInteractiveCommand(sandbox, params);
+  if (result.exitCode === 0) {
+    return;
+  }
+  const stderr = (await result.stderr()).trim();
+  const stdout = (await result.stdout()).trim();
+  const detail = stderr || stdout || "command failed";
+  throw new Error(`${label} failed: ${detail}`);
+}
+async function tryRun(sandbox, params) {
+  const result = await runNonInteractiveCommand(sandbox, params);
+  if (result.exitCode === 0) {
+    return { ok: true };
+  }
+  const stderr = (await result.stderr()).trim();
+  const stdout = (await result.stdout()).trim();
+  return { ok: false, detail: stderr || stdout || "command failed" };
+}
+async function installGhCliViaDnf(sandbox) {
+  const direct = await tryRun(sandbox, {
+    cmd: "dnf",
+    args: ["install", "-y", "gh"],
+    sudo: true
+  });
+  if (direct.ok) {
+    return;
+  }
+  const dnf5Repo = await tryRun(sandbox, {
+    cmd: "dnf",
+    args: [
+      "config-manager",
+      "addrepo",
+      "--from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo"
+    ],
+    sudo: true
+  });
+  if (!dnf5Repo.ok) {
+    await runOrThrow(
+      sandbox,
+      {
+        cmd: "dnf",
+        args: ["install", "-y", "dnf-command(config-manager)"],
+        sudo: true
+      },
+      "dnf install dnf-command(config-manager)"
+    );
+    await runOrThrow(
+      sandbox,
+      {
+        cmd: "dnf",
+        args: [
+          "config-manager",
+          "--add-repo",
+          "https://cli.github.com/packages/rpm/gh-cli.repo"
+        ],
+        sudo: true
+      },
+      "dnf config-manager --add-repo gh-cli.repo"
+    );
+  }
+  await runOrThrow(
+    sandbox,
+    {
+      cmd: "dnf",
+      args: ["install", "-y", "gh", "--repo", "gh-cli"],
+      sudo: true
+    },
+    "dnf install gh --repo gh-cli"
+  );
+}
+function runtimeDependencyFilePath(url, sha256) {
+  let urlBasename = "package.rpm";
+  try {
+    const pathname = new URL(url).pathname;
+    const segments = pathname.split("/").filter(Boolean);
+    const candidate = segments[segments.length - 1];
+    if (candidate) {
+      urlBasename = candidate;
+    }
+  } catch {
+  }
+  const sanitizedBasename = urlBasename.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return `/tmp/junior-runtime-${sha256.slice(0, 12)}-${sanitizedBasename}`;
+}
+async function installRuntimeDependencies(sandbox, deps) {
+  const systemDeps = deps.filter(
+    (dep) => dep.type === "system"
+  );
+  const npmPackages = deps.filter(
+    (dep) => dep.type === "npm"
+  ).map((dep) => `${dep.package}@${dep.version}`);
+  if (systemDeps.length > 0) {
+    await withSnapshotSpan(
+      "sandbox.snapshot.install_system",
+      "sandbox.snapshot.install.system",
+      {
+        "app.sandbox.snapshot.install.system_count": systemDeps.length
+      },
+      async () => {
+        for (const dep of systemDeps) {
+          if ("url" in dep) {
+            const rpmPath = runtimeDependencyFilePath(dep.url, dep.sha256);
+            await runOrThrow(
+              sandbox,
+              {
+                cmd: "curl",
+                args: ["-fsSL", dep.url, "-o", rpmPath]
+              },
+              `curl download ${dep.url}`
+            );
+            const checksumResult = await runNonInteractiveCommand(sandbox, {
+              cmd: "sha256sum",
+              args: [rpmPath]
+            });
+            const checksumStdout = (await checksumResult.stdout()).trim();
+            const checksumStderr = (await checksumResult.stderr()).trim();
+            if (checksumResult.exitCode !== 0) {
+              throw new Error(
+                `sha256sum failed: ${checksumStderr || checksumStdout || "command failed"}`
+              );
+            }
+            const actualChecksum = checksumStdout.split(/\s+/)[0]?.toLowerCase();
+            if (!actualChecksum) {
+              throw new Error("sha256sum produced empty output");
+            }
+            if (actualChecksum !== dep.sha256) {
+              throw new Error(
+                `checksum mismatch for ${dep.url}: expected ${dep.sha256}, got ${actualChecksum}`
+              );
+            }
+            await runOrThrow(
+              sandbox,
+              {
+                cmd: "dnf",
+                args: ["install", "-y", rpmPath],
+                sudo: true
+              },
+              `dnf install ${dep.url}`
+            );
+            continue;
+          }
+          if (dep.package === "gh") {
+            await installGhCliViaDnf(sandbox);
+            continue;
+          }
+          await runOrThrow(
+            sandbox,
+            {
+              cmd: "dnf",
+              args: ["install", "-y", dep.package],
+              sudo: true
+            },
+            `dnf install ${dep.package}`
+          );
+        }
+      }
+    );
+  }
+  if (npmPackages.length > 0) {
+    await withSnapshotSpan(
+      "sandbox.snapshot.install_npm",
+      "sandbox.snapshot.install.npm",
+      {
+        "app.sandbox.snapshot.install.npm_count": npmPackages.length
+      },
+      async () => {
+        await runOrThrow(
+          sandbox,
+          {
+            cmd: "npm",
+            args: [
+              "install",
+              "--global",
+              "--prefix",
+              `${SANDBOX_WORKSPACE_ROOT}/.junior`,
+              ...npmPackages
+            ]
+          },
+          "npm install"
+        );
+      }
+    );
+  }
+}
+async function runRuntimePostinstall(sandbox, commands) {
+  if (commands.length === 0) {
+    return;
+  }
+  await withSnapshotSpan(
+    "sandbox.snapshot.runtime_postinstall",
+    "sandbox.snapshot.runtime_postinstall",
+    {
+      "app.sandbox.snapshot.runtime_postinstall.count": commands.length
+    },
+    async () => {
+      for (const command of commands) {
+        const result = await runNonInteractiveCommand(sandbox, {
+          cmd: command.cmd,
+          args: command.args,
+          login: true,
+          pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
+          ...command.sudo !== void 0 ? { sudo: command.sudo } : {}
+        });
+        if (result.exitCode === 0) {
+          continue;
+        }
+        const stderr = (await result.stderr()).trim();
+        const stdout = (await result.stdout()).trim();
+        const detail = stderr || stdout || "command failed";
+        throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
+      }
+    }
+  );
+}
+async function createDependencySnapshot(profile, runtime, timeoutMs) {
+  return await withSnapshotSpan(
+    "sandbox.snapshot.build",
+    "sandbox.snapshot.build",
+    {
+      "app.sandbox.runtime": runtime,
+      "app.sandbox.snapshot.dependency_count": profile.dependencyCount
+    },
+    async () => {
+      const sandboxCredentials = getVercelSandboxCredentials();
+      const sandbox = createSandboxInstance(
+        await Sandbox.create({
+          timeout: timeoutMs,
+          runtime,
+          ...sandboxCredentials ?? {}
+        })
+      );
+      try {
+        await installRuntimeDependencies(sandbox, profile.dependencies);
+        await runRuntimePostinstall(sandbox, profile.postinstall);
+        return await withSnapshotSpan(
+          "sandbox.snapshot.capture",
+          "sandbox.snapshot.capture",
+          {
+            "app.sandbox.snapshot.dependency_count": profile.dependencyCount
+          },
+          async () => {
+            const snapshot = await sandbox.snapshot();
+            return snapshot.snapshotId;
+          }
+        );
+      } finally {
+        try {
+          await sandbox.stop();
+        } catch {
+        }
+      }
+    }
+  );
+}
+async function withBuildLock(profileHash, callback, canUseCachedSnapshot, hooks) {
+  const state = getStateAdapter();
+  await state.connect();
+  const lockKey = profileLockKey(profileHash);
+  const tryAcquireLock = async () => await state.acquireLock(lockKey, SNAPSHOT_BUILD_LOCK_TTL_MS);
+  let lock = await tryAcquireLock();
+  if (lock) {
+    try {
+      const result = await callback();
+      return {
+        snapshotId: result.snapshotId,
+        source: result.source,
+        waitedForLock: false
+      };
+    } finally {
+      await state.releaseLock(lock);
+    }
+  }
+  return await withSnapshotSpan(
+    "sandbox.snapshot.lock_wait",
+    "sandbox.snapshot.lock_wait",
+    {
+      "app.sandbox.snapshot.profile_hash": profileHash
+    },
+    async () => {
+      await hooks?.onWaitingForLock?.();
+      const waitUntil = Date.now() + SNAPSHOT_WAIT_FOR_LOCK_MS;
+      while (Date.now() < waitUntil) {
+        const cached2 = await getCachedSnapshot(profileHash);
+        if (cached2?.snapshotId && canUseCachedSnapshot(cached2)) {
+          return {
+            snapshotId: cached2.snapshotId,
+            source: "wait_cache",
+            waitedForLock: true
+          };
+        }
+        lock = await tryAcquireLock();
+        if (lock) {
+          try {
+            const result = await callback();
+            return {
+              snapshotId: result.snapshotId,
+              source: result.source,
+              waitedForLock: true
+            };
+          } finally {
+            await state.releaseLock(lock);
+          }
+        }
+        await sleep(500);
+      }
+      const cached = await getCachedSnapshot(profileHash);
+      if (cached?.snapshotId && canUseCachedSnapshot(cached)) {
+        return {
+          snapshotId: cached.snapshotId,
+          source: "wait_cache",
+          waitedForLock: true
+        };
+      }
+      throw new Error("Timed out waiting for snapshot build lock");
+    }
+  );
+}
+function toResolveOutcome(forceRebuild, source, waitedForLock) {
+  if (source === "built") {
+    return forceRebuild ? "forced_rebuild" : "rebuilt";
+  }
+  if (waitedForLock || source === "wait_cache") {
+    return "cache_hit_after_lock_wait";
+  }
+  return "cache_hit";
+}
+function getRebuildReason(params) {
+  if (params.forceRebuild) {
+    return params.staleSnapshotId ? "snapshot_missing" : "force_rebuild";
+  }
+  if (params.cached?.snapshotId && params.shouldRebuildCached) {
+    return "floating_stale";
+  }
+  if (!params.cached?.snapshotId) {
+    return "cache_miss";
+  }
+  return void 0;
+}
+async function resolveRuntimeDependencySnapshot(params) {
+  return await withSnapshotSpan(
+    "sandbox.snapshot.resolve",
+    "sandbox.snapshot.resolve",
+    {
+      "app.sandbox.runtime": params.runtime,
+      "app.sandbox.snapshot.force_rebuild": Boolean(params.forceRebuild)
+    },
+    async () => {
+      await params.onProgress?.("resolve_start");
+      const resolveStartedAtMs = Date.now();
+      const profile = buildDependencyProfile(params.runtime);
+      if (!profile) {
+        return {
+          dependencyCount: 0,
+          cacheHit: false,
+          resolveOutcome: "no_profile"
+        };
+      }
+      const cached = await getCachedSnapshot(profile.profileHash);
+      const cachedNeedsRebuild = Boolean(
+        cached?.snapshotId && shouldRebuildCachedSnapshot(profile, cached)
+      );
+      if (!params.forceRebuild && cached?.snapshotId && !cachedNeedsRebuild) {
+        await params.onProgress?.("cache_hit");
+        return {
+          snapshotId: cached.snapshotId,
+          profileHash: profile.profileHash,
+          dependencyCount: profile.dependencyCount,
+          cacheHit: true,
+          resolveOutcome: "cache_hit"
+        };
+      }
+      const rebuildReason = getRebuildReason({
+        forceRebuild: params.forceRebuild,
+        staleSnapshotId: params.staleSnapshotId,
+        cached,
+        shouldRebuildCached: cachedNeedsRebuild
+      });
+      const canUseCachedSnapshot = (candidate) => {
+        if (params.forceRebuild) {
+          if (params.staleSnapshotId) {
+            return candidate.snapshotId !== params.staleSnapshotId;
+          }
+          return candidate.createdAtMs > resolveStartedAtMs;
+        }
+        return !shouldRebuildCachedSnapshot(profile, candidate);
+      };
+      const lockResult = await withBuildLock(
+        profile.profileHash,
+        async () => {
+          const latest = await getCachedSnapshot(profile.profileHash);
+          if (latest?.snapshotId && canUseCachedSnapshot(latest)) {
+            await params.onProgress?.("cache_hit");
+            return {
+              snapshotId: latest.snapshotId,
+              source: "callback_cache"
+            };
+          }
+          await params.onProgress?.("building_snapshot");
+          const nextSnapshotId = await createDependencySnapshot(
+            profile,
+            params.runtime,
+            params.timeoutMs
+          );
+          await setCachedSnapshot({
+            profileHash: profile.profileHash,
+            snapshotId: nextSnapshotId,
+            runtime: params.runtime,
+            createdAtMs: Date.now(),
+            dependencyCount: profile.dependencyCount
+          });
+          await params.onProgress?.("build_complete");
+          return { snapshotId: nextSnapshotId, source: "built" };
+        },
+        canUseCachedSnapshot,
+        {
+          onWaitingForLock: async () => {
+            await params.onProgress?.("waiting_for_lock");
+          }
+        }
+      );
+      return {
+        snapshotId: lockResult.snapshotId,
+        profileHash: profile.profileHash,
+        dependencyCount: profile.dependencyCount,
+        cacheHit: lockResult.source !== "built",
+        resolveOutcome: toResolveOutcome(
+          Boolean(params.forceRebuild),
+          lockResult.source,
+          lockResult.waitedForLock
+        ),
+        ...rebuildReason ? { rebuildReason } : {}
+      };
+    }
+  );
+}
+function isSnapshotMissingError(error) {
+  const searchable = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return searchable.includes("snapshot") && (searchable.includes("not found") || searchable.includes("unknown") || searchable.includes("404"));
+}
+
+export {
+  SANDBOX_WORKSPACE_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  SANDBOX_DATA_ROOT,
+  sandboxSkillDir,
+  sandboxSkillFile,
+  buildNonInteractiveShellScript,
+  runNonInteractiveCommand,
+  getVercelSandboxCredentials,
+  createSandboxInstance,
+  getRuntimeDependencyProfileHash,
+  resolveRuntimeDependencySnapshot,
+  isSnapshotMissingError
+};