@sentry/junior 0.8.0 → 0.9.0

package/dist/chunk-IJVZEV3K.js

@@ -0,0 +1,840 @@
+import {
+  getPluginRuntimeDependencies,
+  getPluginRuntimePostinstall
+} from "./chunk-ZBWWHP6Q.js";
+import {
+  withSpan
+} from "./chunk-ZW4OVKF5.js";
+
+// src/chat/config.ts
+var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
+var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
+var DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS = 800;
+var TURN_TIMEOUT_BUFFER_SECONDS = 20;
+function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
+  const value = Number.parseInt(rawValue ?? "", 10);
+  if (Number.isNaN(value)) {
+    return Math.max(
+      MIN_AGENT_TURN_TIMEOUT_MS,
+      Math.min(DEFAULT_AGENT_TURN_TIMEOUT_MS, maxTimeoutMs)
+    );
+  }
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(value, maxTimeoutMs));
+}
+function resolveQueueCallbackMaxDurationSeconds(env) {
+  const value = Number.parseInt(
+    env.QUEUE_CALLBACK_MAX_DURATION_SECONDS ?? "",
+    10
+  );
+  if (Number.isNaN(value) || value <= 0) {
+    return DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS;
+  }
+  return value;
+}
+function resolveMaxTurnTimeoutMs(queueCallbackMaxDurationSeconds) {
+  const budgetSeconds = queueCallbackMaxDurationSeconds - TURN_TIMEOUT_BUFFER_SECONDS;
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, budgetSeconds * 1e3);
+}
+function toOptionalTrimmed(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readBotConfig(env) {
+  const queueCallbackMaxDurationSeconds = resolveQueueCallbackMaxDurationSeconds(env);
+  const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(
+    queueCallbackMaxDurationSeconds
+  );
+  return {
+    userName: env.JUNIOR_BOT_NAME ?? "junior",
+    modelId: env.AI_MODEL ?? "anthropic/claude-sonnet-4.6",
+    fastModelId: env.AI_FAST_MODEL ?? env.AI_MODEL ?? "anthropic/claude-haiku-4.5",
+    turnTimeoutMs: parseAgentTurnTimeoutMs(
+      env.AGENT_TURN_TIMEOUT_MS,
+      maxTurnTimeoutMs
+    )
+  };
+}
+function readChatConfig(env = process.env) {
+  return {
+    bot: readBotConfig(env),
+    queue: {
+      callbackMaxDurationSeconds: resolveQueueCallbackMaxDurationSeconds(env)
+    },
+    slack: {
+      botToken: toOptionalTrimmed(env.SLACK_BOT_TOKEN) ?? toOptionalTrimmed(env.SLACK_BOT_USER_TOKEN),
+      signingSecret: toOptionalTrimmed(env.SLACK_SIGNING_SECRET),
+      clientId: toOptionalTrimmed(env.SLACK_CLIENT_ID),
+      clientSecret: toOptionalTrimmed(env.SLACK_CLIENT_SECRET)
+    },
+    state: {
+      adapter: env.JUNIOR_STATE_ADAPTER?.trim().toLowerCase() === "memory" ? "memory" : "redis",
+      redisUrl: toOptionalTrimmed(env.REDIS_URL)
+    }
+  };
+}
+var chatConfig = readChatConfig(process.env);
+function getChatConfig() {
+  return chatConfig;
+}
+var botConfig = chatConfig.bot;
+function getSlackBotToken() {
+  return chatConfig.slack.botToken;
+}
+function getSlackSigningSecret() {
+  return chatConfig.slack.signingSecret;
+}
+function getSlackClientId() {
+  return chatConfig.slack.clientId;
+}
+function getSlackClientSecret() {
+  return chatConfig.slack.clientSecret;
+}
+function getRuntimeMetadata() {
+  return {
+    version: toOptionalTrimmed(process.env.VERCEL_GIT_COMMIT_SHA)
+  };
+}
+
+// src/chat/state/adapter.ts
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { createRedisState } from "@chat-adapter/state-redis";
+var MIN_LOCK_TTL_MS = 1e3 * 60 * 5;
+var stateAdapter;
+var redisStateAdapter;
+function createQueuedStateAdapter(base) {
+  const acquireLock = async (threadId, ttlMs) => {
+    const effectiveTtlMs = Math.max(ttlMs, MIN_LOCK_TTL_MS);
+    return await base.acquireLock(threadId, effectiveTtlMs);
+  };
+  return {
+    appendToList: (key, value, options) => base.appendToList(key, value, options),
+    connect: () => base.connect(),
+    disconnect: () => base.disconnect(),
+    subscribe: (threadId) => base.subscribe(threadId),
+    unsubscribe: (threadId) => base.unsubscribe(threadId),
+    isSubscribed: (threadId) => base.isSubscribed(threadId),
+    acquireLock,
+    releaseLock: (lock) => base.releaseLock(lock),
+    extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
+    forceReleaseLock: (threadId) => base.forceReleaseLock(threadId),
+    get: (key) => base.get(key),
+    getList: (key) => base.getList(key),
+    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
+    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
+    delete: (key) => base.delete(key)
+  };
+}
+function createStateAdapter() {
+  const config = getChatConfig();
+  if (config.state.adapter === "memory") {
+    redisStateAdapter = void 0;
+    return createQueuedStateAdapter(createMemoryState());
+  }
+  if (!config.state.redisUrl) {
+    throw new Error("REDIS_URL is required for durable Slack thread state");
+  }
+  const redisState = createRedisState({
+    url: config.state.redisUrl
+  });
+  redisStateAdapter = redisState;
+  return createQueuedStateAdapter(redisState);
+}
+function getOptionalRedisStateAdapter() {
+  getStateAdapter();
+  return redisStateAdapter;
+}
+async function getConnectedStateContext() {
+  const adapter = getStateAdapter();
+  await adapter.connect();
+  return {
+    redisStateAdapter: getOptionalRedisStateAdapter(),
+    stateAdapter: adapter
+  };
+}
+function getStateAdapter() {
+  if (!stateAdapter) {
+    stateAdapter = createStateAdapter();
+  }
+  return stateAdapter;
+}
+async function disconnectStateAdapter() {
+  if (!stateAdapter) {
+    return;
+  }
+  try {
+    await stateAdapter.disconnect();
+  } finally {
+    stateAdapter = void 0;
+    redisStateAdapter = void 0;
+  }
+}
+
+// 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"
+};
+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(runner, input) {
+  return await runner.runCommand({
+    ...buildNonInteractiveCommand(input),
+    ...input.cwd ? { cwd: input.cwd } : {},
+    ...input.sudo !== void 0 ? { sudo: input.sudo } : {}
+  });
+}
+
+// src/chat/sandbox/credentials.ts
+function toOptionalTrimmed2(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function getVercelSandboxCredentials() {
+  const token = toOptionalTrimmed2(process.env.VERCEL_TOKEN);
+  const teamId = toOptionalTrimmed2(process.env.VERCEL_TEAM_ID);
+  const projectId = toOptionalTrimmed2(process.env.VERCEL_PROJECT_ID);
+  if (!token && !teamId && !projectId) {
+    return void 0;
+  }
+  if (!token || !teamId || !projectId) {
+    throw new Error(
+      "Missing Vercel Sandbox credentials: set VERCEL_TOKEN, VERCEL_TEAM_ID, and VERCEL_PROJECT_ID together."
+    );
+  }
+  return {
+    token,
+    teamId,
+    projectId
+  };
+}
+
+// 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`;
+function sandboxSkillDir(skillName) {
+  return `${SANDBOX_SKILLS_ROOT}/${skillName}`;
+}
+
+// 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 = 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({ blocking: true });
+        } 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 {
+  botConfig,
+  getSlackBotToken,
+  getSlackSigningSecret,
+  getSlackClientId,
+  getSlackClientSecret,
+  getRuntimeMetadata,
+  getConnectedStateContext,
+  getStateAdapter,
+  disconnectStateAdapter,
+  SANDBOX_WORKSPACE_ROOT,
+  SANDBOX_SKILLS_ROOT,
+  sandboxSkillDir,
+  buildNonInteractiveShellScript,
+  runNonInteractiveCommand,
+  getVercelSandboxCredentials,
+  getRuntimeDependencyProfileHash,
+  resolveRuntimeDependencySnapshot,
+  isSnapshotMissingError
+};