@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-LA6R4A7Q.js

@@ -1,706 +0,0 @@
-import {
-  SANDBOX_WORKSPACE_ROOT,
-  create,
-  getVercelSandboxCredentials,
-  isSandboxUnavailableError,
-  isStale,
-  runNonInteractiveCommand,
-  sleep
-} from "./chunk-NSXKRGRT.js";
-import {
-  getStateAdapter
-} from "./chunk-2MK3QBGA.js";
-import {
-  setSpanAttributes,
-  withSpan
-} from "./chunk-MAGNK5J4.js";
-
-// src/chat/sandbox/resources.ts
-var configuredResources;
-function resourcesFromEnv() {
-  const value = process.env.SANDBOX_VCPUS?.trim();
-  if (!value || !/^\d+$/.test(value)) {
-    return void 0;
-  }
-  const vcpus = Number(value);
-  if (!Number.isSafeInteger(vcpus) || vcpus <= 0) {
-    return void 0;
-  }
-  return { vcpus };
-}
-function getSandboxResourceConfig() {
-  return configuredResources;
-}
-function setSandboxResourceConfig(config) {
-  const previous = configuredResources;
-  if (config?.vcpus === void 0) {
-    configuredResources = void 0;
-    return previous;
-  }
-  if (!Number.isSafeInteger(config.vcpus) || config.vcpus <= 0) {
-    throw new Error("sandbox.vcpus must be a positive integer");
-  }
-  configuredResources = { vcpus: config.vcpus };
-  return previous;
-}
-function getSandboxResources() {
-  return configuredResources ?? resourcesFromEnv();
-}
-
-// src/chat/sandbox/snapshot/resolve.ts
-import { Sandbox } from "@vercel/sandbox";
-import { z } from "zod";
-
-// src/chat/sandbox/snapshot/span.ts
-function setSnapshotSpanAttributes(snapshot) {
-  setSpanAttributes({
-    "app.sandbox.source": snapshot.snapshotId ? "snapshot" : "created",
-    "app.sandbox.snapshot.cache_hit": snapshot.cacheHit,
-    "app.sandbox.snapshot.resolve_outcome": snapshot.resolveOutcome,
-    ...snapshot.profileHash ? { "app.sandbox.snapshot.profile_hash": snapshot.profileHash } : void 0,
-    "app.sandbox.snapshot.dependency_count": snapshot.dependencyCount,
-    ...snapshot.rebuildReason ? { "app.sandbox.snapshot.rebuild_reason": snapshot.rebuildReason } : void 0
-  });
-}
-async function trace(name, op, attributes, callback) {
-  return await withSpan(name, op, {}, callback, attributes);
-}
-
-// src/chat/sandbox/snapshot/install.ts
-async function runOrThrow(sandbox, params, label) {
-  const result = await runNonInteractiveCommand(sandbox, params);
-  if (result.exitCode === 0) {
-    return;
-  }
-  const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
-  throw new Error(`${label} failed: ${detail}`);
-}
-async function tryRun(sandbox, params) {
-  const result = await runNonInteractiveCommand(sandbox, params);
-  return result.exitCode === 0;
-}
-async function installGh(sandbox, signal, timeoutMs) {
-  const installed = await tryRun(sandbox, {
-    cmd: "dnf",
-    args: ["install", "-y", "gh"],
-    signal,
-    sudo: true,
-    timeoutMs
-  });
-  if (installed) {
-    return;
-  }
-  const repoAdded = await tryRun(sandbox, {
-    cmd: "dnf",
-    args: [
-      "config-manager",
-      "addrepo",
-      "--from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo"
-    ],
-    signal,
-    sudo: true,
-    timeoutMs
-  });
-  if (!repoAdded) {
-    await runOrThrow(
-      sandbox,
-      {
-        cmd: "dnf",
-        args: ["install", "-y", "dnf-command(config-manager)"],
-        signal,
-        sudo: true,
-        timeoutMs
-      },
-      "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"
-        ],
-        signal,
-        sudo: true,
-        timeoutMs
-      },
-      "dnf config-manager --add-repo gh-cli.repo"
-    );
-  }
-  await runOrThrow(
-    sandbox,
-    {
-      cmd: "dnf",
-      args: ["install", "-y", "gh", "--repo", "gh-cli"],
-      signal,
-      sudo: true,
-      timeoutMs
-    },
-    "dnf install gh --repo gh-cli"
-  );
-}
-function filePath(url, sha256) {
-  let basename = "package.rpm";
-  try {
-    const candidate = new URL(url).pathname.split("/").filter(Boolean).at(-1);
-    if (candidate) {
-      basename = candidate;
-    }
-  } catch {
-  }
-  const sanitized = basename.replace(/[^a-zA-Z0-9._-]/g, "_");
-  return `/tmp/junior-runtime-${sha256.slice(0, 12)}-${sanitized}`;
-}
-async function installUrl(sandbox, dependency, signal, timeoutMs) {
-  const rpmPath = filePath(dependency.url, dependency.sha256);
-  await runOrThrow(
-    sandbox,
-    {
-      cmd: "curl",
-      args: ["-fsSL", dependency.url, "-o", rpmPath],
-      signal,
-      timeoutMs
-    },
-    `curl download ${dependency.url}`
-  );
-  const checksum = await runNonInteractiveCommand(sandbox, {
-    cmd: "sha256sum",
-    args: [rpmPath],
-    signal,
-    timeoutMs
-  });
-  const expected = dependency.sha256;
-  const actual = checksum.stdout.trim().split(/\s+/)[0]?.toLowerCase();
-  if (checksum.exitCode !== 0) {
-    const detail = checksum.stderr.trim() || checksum.stdout.trim() || "command failed";
-    throw new Error(`sha256sum failed: ${detail}`);
-  }
-  if (!actual) {
-    throw new Error("sha256sum produced empty output");
-  }
-  if (actual !== expected) {
-    throw new Error(
-      `checksum mismatch for ${dependency.url}: expected ${expected}, got ${actual}`
-    );
-  }
-  await runOrThrow(
-    sandbox,
-    {
-      cmd: "dnf",
-      args: ["install", "-y", rpmPath],
-      signal,
-      sudo: true,
-      timeoutMs
-    },
-    `dnf install ${dependency.url}`
-  );
-}
-async function dependencies(sandbox, values, signal, timeoutMs) {
-  const system = values.filter(
-    (dependency) => dependency.type === "system"
-  );
-  const npm = values.filter(
-    (dependency) => dependency.type === "npm"
-  ).map((dependency) => `${dependency.package}@${dependency.version}`);
-  if (system.length > 0) {
-    await trace(
-      "sandbox.snapshot.install_system",
-      "sandbox.snapshot.install.system",
-      {
-        "app.sandbox.snapshot.install.system_count": system.length
-      },
-      async () => {
-        for (const dependency of system) {
-          signal?.throwIfAborted();
-          if ("url" in dependency) {
-            await installUrl(sandbox, dependency, signal, timeoutMs);
-          } else if (dependency.package === "gh") {
-            await installGh(sandbox, signal, timeoutMs);
-          } else {
-            await runOrThrow(
-              sandbox,
-              {
-                cmd: "dnf",
-                args: ["install", "-y", dependency.package],
-                signal,
-                sudo: true,
-                timeoutMs
-              },
-              `dnf install ${dependency.package}`
-            );
-          }
-        }
-      }
-    );
-  }
-  if (npm.length > 0) {
-    await trace(
-      "sandbox.snapshot.install_npm",
-      "sandbox.snapshot.install.npm",
-      {
-        "app.sandbox.snapshot.install.npm_count": npm.length
-      },
-      async () => {
-        await runOrThrow(
-          sandbox,
-          {
-            cmd: "npm",
-            args: [
-              "install",
-              "--global",
-              "--prefix",
-              `${SANDBOX_WORKSPACE_ROOT}/.junior`,
-              ...npm
-            ],
-            signal,
-            timeoutMs
-          },
-          "npm install"
-        );
-      }
-    );
-  }
-}
-async function postinstall(sandbox, commands, signal, timeoutMs) {
-  if (commands.length === 0) {
-    return;
-  }
-  await trace(
-    "sandbox.snapshot.runtime_postinstall",
-    "sandbox.snapshot.runtime_postinstall",
-    {
-      "app.sandbox.snapshot.runtime_postinstall.count": commands.length
-    },
-    async () => {
-      for (const command of commands) {
-        signal?.throwIfAborted();
-        const result = await runNonInteractiveCommand(sandbox, {
-          cmd: command.cmd,
-          args: command.args,
-          login: true,
-          pathPrefix: `${SANDBOX_WORKSPACE_ROOT}/.junior/bin:$PATH`,
-          signal,
-          timeoutMs,
-          ...command.sudo !== void 0 ? { sudo: command.sudo } : void 0
-        });
-        if (result.exitCode !== 0) {
-          const detail = result.stderr.trim() || result.stdout.trim() || "command failed";
-          throw new Error(
-            `runtime-postinstall ${command.cmd} failed: ${detail}`
-          );
-        }
-      }
-    }
-  );
-}
-
-// src/chat/sandbox/workspace.ts
-import {
-  FileSystem
-} from "@vercel/sandbox";
-function bindSandboxFileSystem(fs, signal) {
-  if (!signal) {
-    return fs;
-  }
-  return {
-    readFile(filePath2, options) {
-      signal.throwIfAborted();
-      return fs.readFile(filePath2, { ...options, signal });
-    },
-    writeFile(filePath2, content, options) {
-      signal.throwIfAborted();
-      return fs.writeFile(filePath2, content, { ...options, signal });
-    },
-    readdir(filePath2) {
-      signal.throwIfAborted();
-      return fs.readdir(filePath2, { signal });
-    },
-    stat(filePath2) {
-      signal.throwIfAborted();
-      return fs.stat(filePath2, { signal });
-    }
-  };
-}
-function createSandboxSession(sandbox, options) {
-  const session = sandbox.currentSession();
-  const fileSystem = new FileSystem(session);
-  const run = async (operation) => {
-    try {
-      return await operation();
-    } catch (error) {
-      if (isSandboxUnavailableError(error)) {
-        options?.onUnavailable?.(session.sessionId);
-      }
-      throw error;
-    }
-  };
-  const fs = {
-    readFile: async (filePath2, readOptions) => await run(async () => await fileSystem.readFile(filePath2, readOptions)),
-    writeFile: async (filePath2, content, writeOptions) => await run(
-      async () => await fileSystem.writeFile(filePath2, content, writeOptions)
-    ),
-    readdir: async (filePath2, readOptions) => await run(async () => await fileSystem.readdir(filePath2, readOptions)),
-    stat: async (filePath2, statOptions) => await run(async () => await fileSystem.stat(filePath2, statOptions))
-  };
-  return {
-    sandboxId: sandbox.name,
-    sessionId: session.sessionId,
-    fs,
-    extendTimeout(duration) {
-      return run(async () => await session.extendTimeout(duration));
-    },
-    mkDir(path) {
-      return run(async () => await session.mkDir(path));
-    },
-    readFileToBuffer(input) {
-      return run(async () => await session.readFileToBuffer(input));
-    },
-    async runCommand(input) {
-      const result = await run(async () => await session.runCommand(input));
-      const [stdout, stderr] = await Promise.all([
-        run(async () => await result.stdout()),
-        run(async () => await result.stderr())
-      ]);
-      return {
-        exitCode: result.exitCode,
-        stdout,
-        stderr
-      };
-    },
-    snapshot(options2) {
-      return run(async () => {
-        const snapshot = await session.snapshot(options2);
-        return { snapshotId: snapshot.snapshotId };
-      });
-    },
-    stop() {
-      return run(async () => await session.stop());
-    },
-    update(params) {
-      return run(async () => await session.update(params));
-    },
-    writeFiles(files) {
-      return run(async () => await session.writeFiles(files));
-    }
-  };
-}
-async function stopSession(session) {
-  if (!session) return;
-  try {
-    await session.stop();
-  } catch {
-  }
-}
-
-// src/chat/sandbox/snapshot/resolve.ts
-var SNAPSHOT_CACHE_PREFIX = "junior:sandbox_snapshot_profile:v2";
-var SNAPSHOT_LOCK_PREFIX = "junior:sandbox_snapshot_lock";
-var SNAPSHOT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var SNAPSHOT_BUILD_LOCK_BUFFER_MS = 30 * 1e3;
-var SNAPSHOT_WAIT_FOR_LOCK_BUFFER_MS = 30 * 1e3;
-var cachedSnapshotSchema = z.object({
-  profileHash: z.string(),
-  snapshotId: z.string(),
-  runtime: z.string(),
-  createdAtMs: z.number(),
-  dependencyCount: z.number(),
-  buildDurationMs: z.number().int().nonnegative()
-}).strict();
-function profileCacheKey(profileHash) {
-  return `${SNAPSHOT_CACHE_PREFIX}:${profileHash}`;
-}
-function profileLockKey(profileHash) {
-  return `${SNAPSHOT_LOCK_PREFIX}:${profileHash}`;
-}
-async function getCachedSnapshot(profileHash) {
-  const state = getStateAdapter();
-  await state.connect();
-  const raw = await state.get(profileCacheKey(profileHash));
-  if (typeof raw !== "string") {
-    return null;
-  }
-  let value;
-  try {
-    value = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid cached sandbox snapshot for ${profileHash}`);
-  }
-  const parsed = cachedSnapshotSchema.safeParse(value);
-  if (!parsed.success || parsed.data.profileHash !== profileHash) {
-    throw new Error(`Invalid cached sandbox snapshot for ${profileHash}`);
-  }
-  return parsed.data;
-}
-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 build(value, runtime, timeoutMs, signal, prepare) {
-  return await trace(
-    "sandbox.snapshot.build",
-    "sandbox.snapshot.build",
-    {
-      "app.sandbox.runtime": runtime,
-      "app.sandbox.snapshot.dependency_count": value.dependencyCount
-    },
-    async () => {
-      const startedAtMs = Date.now();
-      const sandboxCredentials = getVercelSandboxCredentials();
-      const resources = getSandboxResources();
-      const sandbox = createSandboxSession(
-        await Sandbox.create({
-          timeout: timeoutMs,
-          runtime,
-          signal,
-          ...sandboxCredentials ?? {},
-          ...resources ? { resources } : void 0
-        })
-      );
-      try {
-        await dependencies(sandbox, value.dependencies, signal);
-        await postinstall(sandbox, value.postinstall, signal);
-        await prepare?.(sandbox);
-        const snapshotId = await trace(
-          "sandbox.snapshot.capture",
-          "sandbox.snapshot.capture",
-          {
-            "app.sandbox.snapshot.dependency_count": value.dependencyCount
-          },
-          async () => {
-            const snapshot = await sandbox.snapshot({ signal });
-            return snapshot.snapshotId;
-          }
-        );
-        return {
-          snapshotId,
-          buildDurationMs: Math.max(0, Date.now() - startedAtMs)
-        };
-      } finally {
-        try {
-          await sandbox.stop();
-        } catch {
-        }
-      }
-    }
-  );
-}
-async function withBuildLock(profileHash, timeoutMs, callback, canUseCachedSnapshot, onWaitingForLock, signal) {
-  signal?.throwIfAborted();
-  const state = getStateAdapter();
-  await state.connect();
-  const lockKey = profileLockKey(profileHash);
-  const lockTtlMs = timeoutMs + SNAPSHOT_BUILD_LOCK_BUFFER_MS;
-  const tryAcquireLock = async () => await state.acquireLock(lockKey, lockTtlMs);
-  let lock = await tryAcquireLock();
-  if (lock) {
-    try {
-      return await callback();
-    } finally {
-      await state.releaseLock(lock);
-    }
-  }
-  return await trace(
-    "sandbox.snapshot.lock_wait",
-    "sandbox.snapshot.lock_wait",
-    {
-      "app.sandbox.snapshot.profile_hash": profileHash
-    },
-    async () => {
-      await onWaitingForLock?.();
-      const waitUntil = Date.now() + lockTtlMs + SNAPSHOT_WAIT_FOR_LOCK_BUFFER_MS;
-      while (Date.now() < waitUntil) {
-        signal?.throwIfAborted();
-        const cached2 = await getCachedSnapshot(profileHash);
-        if (cached2?.snapshotId && canUseCachedSnapshot(cached2)) {
-          return {
-            snapshotId: cached2.snapshotId,
-            source: "cache_hit_after_lock_wait",
-            createdAtMs: cached2.createdAtMs,
-            buildDurationMs: cached2.buildDurationMs
-          };
-        }
-        lock = await tryAcquireLock();
-        if (lock) {
-          try {
-            const result = await callback();
-            return {
-              snapshotId: result.snapshotId,
-              source: result.source === "built" ? "built" : "cache_hit_after_lock_wait",
-              createdAtMs: result.createdAtMs,
-              buildDurationMs: result.buildDurationMs
-            };
-          } finally {
-            await state.releaseLock(lock);
-          }
-        }
-        await sleep(500, signal);
-      }
-      signal?.throwIfAborted();
-      const cached = await getCachedSnapshot(profileHash);
-      if (cached?.snapshotId && canUseCachedSnapshot(cached)) {
-        return {
-          snapshotId: cached.snapshotId,
-          source: "cache_hit_after_lock_wait",
-          createdAtMs: cached.createdAtMs,
-          buildDurationMs: cached.buildDurationMs
-        };
-      }
-      throw new Error("Timed out waiting for snapshot build lock");
-    }
-  );
-}
-function toResolveOutcome(forceRebuild, source) {
-  if (source === "built") {
-    return forceRebuild ? "forced_rebuild" : "rebuilt";
-  }
-  return source;
-}
-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 resolve(params) {
-  return await trace(
-    "sandbox.snapshot.resolve",
-    "sandbox.snapshot.resolve",
-    {
-      "app.sandbox.runtime": params.runtime,
-      "app.sandbox.snapshot.force_rebuild": Boolean(params.forceRebuild)
-    },
-    async () => {
-      params.signal?.throwIfAborted();
-      await params.onProgress?.("resolve_start");
-      const currentProfile = create(params.runtime, params.workspace);
-      if (!currentProfile) {
-        return {
-          dependencyCount: 0,
-          cacheHit: false,
-          resolveOutcome: "no_profile"
-        };
-      }
-      const cached = await getCachedSnapshot(currentProfile.hash);
-      const cachedNeedsRebuild = Boolean(
-        cached?.snapshotId && isStale(currentProfile, cached.createdAtMs)
-      );
-      if (!params.forceRebuild && cached?.snapshotId && !cachedNeedsRebuild) {
-        await params.onProgress?.("cache_hit");
-        return {
-          snapshotId: cached.snapshotId,
-          profileHash: currentProfile.hash,
-          dependencyCount: currentProfile.dependencyCount,
-          cacheHit: true,
-          resolveOutcome: "cache_hit",
-          createdAtMs: cached.createdAtMs,
-          buildDurationMs: cached.buildDurationMs
-        };
-      }
-      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.snapshotId !== cached?.snapshotId;
-        }
-        return !isStale(currentProfile, candidate.createdAtMs);
-      };
-      const lockResult = await withBuildLock(
-        currentProfile.hash,
-        params.timeoutMs,
-        async () => {
-          const latest = await getCachedSnapshot(currentProfile.hash);
-          if (latest?.snapshotId && canUseCachedSnapshot(latest)) {
-            await params.onProgress?.("cache_hit");
-            return {
-              snapshotId: latest.snapshotId,
-              source: "cache_hit",
-              createdAtMs: latest.createdAtMs,
-              buildDurationMs: latest.buildDurationMs
-            };
-          }
-          await params.onProgress?.("building_snapshot");
-          const built = await build(
-            currentProfile,
-            params.runtime,
-            params.timeoutMs,
-            params.signal,
-            params.prepareWorkspace
-          );
-          const createdAtMs = Date.now();
-          await setCachedSnapshot({
-            profileHash: currentProfile.hash,
-            snapshotId: built.snapshotId,
-            runtime: params.runtime,
-            createdAtMs,
-            dependencyCount: currentProfile.dependencyCount,
-            buildDurationMs: built.buildDurationMs
-          });
-          await params.onProgress?.("build_complete");
-          return {
-            snapshotId: built.snapshotId,
-            source: "built",
-            createdAtMs,
-            buildDurationMs: built.buildDurationMs
-          };
-        },
-        canUseCachedSnapshot,
-        async () => {
-          await params.onProgress?.("waiting_for_lock");
-        },
-        params.signal
-      );
-      return {
-        snapshotId: lockResult.snapshotId,
-        profileHash: currentProfile.hash,
-        dependencyCount: currentProfile.dependencyCount,
-        cacheHit: lockResult.source !== "built",
-        resolveOutcome: toResolveOutcome(
-          Boolean(params.forceRebuild),
-          lockResult.source
-        ),
-        createdAtMs: lockResult.createdAtMs,
-        buildDurationMs: lockResult.buildDurationMs,
-        ...rebuildReason ? { rebuildReason } : void 0
-      };
-    }
-  );
-}
-function isMissingError(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 {
-  getSandboxResourceConfig,
-  setSandboxResourceConfig,
-  getSandboxResources,
-  setSnapshotSpanAttributes,
-  dependencies,
-  postinstall,
-  bindSandboxFileSystem,
-  createSandboxSession,
-  stopSession,
-  getCachedSnapshot,
-  resolve,
-  isMissingError
-};