@sentry/junior 0.177.0 → 0.179.0

package/dist/chat/workspaces/types.d.ts

@@ -15,6 +15,7 @@ export type WorkspaceSnapshotStatus = WorkspaceSnapshotBuildStatus | "ready";
 export type WorkspaceSnapshotBuildPhase = "created" | "dependencies_installed" | "repositories_prepared";
 /** Current snapshot build for one Workspace recipe. */
 export interface WorkspaceSnapshotBuild {
+    id: string;
     status: WorkspaceSnapshotBuildStatus;
     phase: WorkspaceSnapshotBuildPhase;
     profileHash: string;

package/dist/{chunk-CAWBLVBY.js → chunk-2HIPYNQI.js}

@@ -5,19 +5,19 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-PA7QDS7P.js";
+} from "./chunk-3I7XE3PA.js";
 import {
   parseDestination
-} from "./chunk-LPMLAJYR.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   getStateAdapter
-} from "./chunk-VGDOEKO2.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-J2EWL6GJ.js";
+} from "./chunk-YFNAMRGE.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -26,7 +26,7 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-7CVYXUOJ.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;

package/dist/{chunk-ZCYABD7N.js → chunk-3AFVR5UC.js}

@@ -4,7 +4,7 @@ import {
 import {
   formatProviderLabel,
   startOAuthFlow
-} from "./chunk-CAWBLVBY.js";
+} from "./chunk-2HIPYNQI.js";
 import {
   parseSandboxEgressAuthRequiredSignal
 } from "./chunk-6ZWRNC4D.js";
@@ -12,16 +12,16 @@ import {
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
   recordAuthorizationRequested
-} from "./chunk-I7PKGMKI.js";
+} from "./chunk-FIDMHAO6.js";
 import {
   AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-WCQUKX74.js";
+} from "./chunk-R6U7N4FS.js";
 import {
   TURN_REASONING_LEVELS
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-J2EWL6GJ.js";
+} from "./chunk-YFNAMRGE.js";
 import {
   credentialContextSchema
 } from "./chunk-CGA4ERJ5.js";

package/dist/{chunk-PA7QDS7P.js → chunk-3I7XE3PA.js}

@@ -5,7 +5,7 @@ import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-LPMLAJYR.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
@@ -14,23 +14,25 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-WCQUKX74.js";
+} from "./chunk-R6U7N4FS.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
+  getVercelSandboxCredentials,
   hash,
+  isSandboxMissingError,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-Q362TECJ.js";
+} from "./chunk-JMJNFEDC.js";
 import {
   getStateAdapter
-} from "./chunk-VGDOEKO2.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -46,7 +48,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-7CVYXUOJ.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -1664,15 +1666,65 @@ function workspaceRepoCheckoutPath(repo) {
 }
 
 // src/chat/workspaces/store.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { and as and5, asc as asc2, eq as eq5, sql as sql2 } from "drizzle-orm";
+import { randomUUID as randomUUID2 } from "crypto";
+import { and as and5, asc as asc3, eq as eq5, sql as sql2 } from "drizzle-orm";
+
+// src/chat/sandbox/snapshot/builder-sandbox.ts
+import { Sandbox } from "@vercel/sandbox";
+async function getWorkspaceSnapshotBuilder(name, signal) {
+  const credentials = getVercelSandboxCredentials();
+  return await Sandbox.get({
+    name,
+    resume: true,
+    signal,
+    ...credentials ?? {}
+  });
+}
+async function deleteWorkspaceSnapshotBuilders(names) {
+  const credentials = getVercelSandboxCredentials();
+  let hasError = false;
+  let firstError;
+  for (const name of new Set(names)) {
+    try {
+      const sandbox = await Sandbox.get({
+        name,
+        resume: false,
+        ...credentials ?? {}
+      });
+      await sandbox.delete();
+    } catch (error) {
+      if (!isSandboxMissingError(error)) {
+        if (!hasError) firstError = error;
+        hasError = true;
+      }
+    }
+  }
+  if (hasError) throw firstError;
+}
 
 // src/chat/sandbox/snapshot/runtime.ts
 var SANDBOX_RUNTIME = "node22";
 
 // src/chat/sandbox/snapshot/store.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { and as and4, desc as desc2, eq as eq4, ne } from "drizzle-orm";
+import { and as and4, asc as asc2, desc as desc2, eq as eq4, ne, or } from "drizzle-orm";
+function builderNames(rows) {
+  return [
+    ...new Set(
+      rows.map((row) => row.sandboxName).filter((name) => Boolean(name))
+    )
+  ];
+}
+function sameWorkspaceRecipe(stored, expected) {
+  if (stored.setupScript !== expected.setupScript || stored.repos.length !== expected.repos.length) {
+    return false;
+  }
+  const expectedRepos = new Set(
+    expected.repos.map((repo) => JSON.stringify([repo.provider, repo.repo]))
+  );
+  return stored.repos.every(
+    (repo) => expectedRepos.has(JSON.stringify([repo.provider, repo.repo]))
+  );
+}
 function snapshotFromRow(row) {
   if (row.status !== "ready" || !row.snapshotId || !row.generatedAt || row.buildDurationMs == null) {
     throw new Error(`Invalid ready Workspace snapshot row: ${row.id}`);
@@ -1689,6 +1741,7 @@ function snapshotBuildFromRow(row) {
     throw new Error(`Invalid Workspace snapshot build row: ${row.id}`);
   }
   return {
+    id: row.id,
     status: row.status,
     phase: row.buildPhase,
     profileHash: row.profileHash,
@@ -1710,99 +1763,131 @@ async function loadSnapshotsForProfile(db, workspaceId, profileHash) {
   ];
   const [readyRows, buildRows] = await Promise.all([
     db.select().from(juniorSnapshots).where(and4(profile, eq4(juniorSnapshots.status, "ready"))).orderBy(...order).limit(1),
-    db.select().from(juniorSnapshots).where(and4(profile, ne(juniorSnapshots.status, "ready"))).orderBy(...order).limit(1)
+    db.select().from(juniorSnapshots).where(and4(profile, ne(juniorSnapshots.status, "ready"))).orderBy(asc2(juniorSnapshots.status), ...order).limit(1)
   ]);
   return {
     ready: readyRows[0] ? snapshotFromRow(readyRows[0]) : null,
     build: buildRows[0] ? snapshotBuildFromRow(buildRows[0]) : null
   };
 }
-async function clearNonReadySnapshots(db, workspaceId) {
-  const deleted = await db.delete(juniorSnapshots).where(
-    and4(
-      eq4(juniorSnapshots.workspaceId, workspaceId),
-      ne(juniorSnapshots.status, "ready")
-    )
-  ).returning({
-    sandboxName: juniorSnapshots.buildSandboxName
-  });
-  return deleted.map((row) => row.sandboxName).filter((name) => Boolean(name));
+async function clearWorkspaceSnapshots(db, workspaceId) {
+  await db.select({ id: juniorWorkspaces.id }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
+  const deleted = await db.delete(juniorSnapshots).where(eq4(juniorSnapshots.workspaceId, workspaceId)).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+  return builderNames(deleted);
 }
-async function setWorkspaceSnapshot(workspaceId, snapshot) {
+async function invalidateReadySnapshot(params) {
   const executor = getSqlExecutor();
-  await executor.transaction(async () => {
+  return await executor.transaction(async () => {
     const db = executor.db();
-    const workspaceRows = await db.select({ id: juniorWorkspaces.id }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).limit(1);
-    if (!workspaceRows[0]) return;
-    const now = /* @__PURE__ */ new Date();
-    const existing = await db.select().from(juniorSnapshots).where(
+    const deleted = await db.delete(juniorSnapshots).where(
       and4(
-        eq4(juniorSnapshots.workspaceId, workspaceId),
-        eq4(juniorSnapshots.profileHash, snapshot.profileHash)
+        eq4(juniorSnapshots.workspaceId, params.workspaceId),
+        eq4(juniorSnapshots.profileHash, params.profileHash),
+        eq4(juniorSnapshots.status, "ready"),
+        eq4(juniorSnapshots.snapshotId, params.snapshotId)
       )
-    ).orderBy(desc2(juniorSnapshots.updatedAt), desc2(juniorSnapshots.createdAt)).limit(1);
-    const current = existing[0];
-    if (current && current.status !== "ready") {
-      await db.update(juniorSnapshots).set({
-        status: "ready",
-        snapshotId: snapshot.id,
-        buildDurationMs: snapshot.buildDurationMs,
-        generatedAt: snapshot.generatedAt,
-        buildStartedAt: null,
-        buildPhase: null,
-        buildSandboxName: null,
-        buildCommandId: null,
-        buildError: null,
-        updatedAt: now
-      }).where(eq4(juniorSnapshots.id, current.id));
-      return;
-    }
-    if (current && current.status === "ready" && current.snapshotId === snapshot.id) {
-      await db.update(juniorSnapshots).set({
-        buildDurationMs: snapshot.buildDurationMs,
-        generatedAt: snapshot.generatedAt,
-        buildStartedAt: null,
-        buildPhase: null,
-        buildSandboxName: null,
-        buildCommandId: null,
-        buildError: null,
-        updatedAt: now
-      }).where(eq4(juniorSnapshots.id, current.id));
-      return;
-    }
-    await db.insert(juniorSnapshots).values({
-      id: randomUUID2(),
-      workspaceId,
-      profileHash: snapshot.profileHash,
+    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+    return deleted[0]?.sandboxName ?? null;
+  });
+}
+async function setWorkspaceSnapshot(workspaceId, snapshot, options) {
+  const executor = getSqlExecutor();
+  return await executor.transaction(async () => {
+    const db = executor.db();
+    const now = /* @__PURE__ */ new Date();
+    const updated = await db.update(juniorSnapshots).set({
       status: "ready",
       snapshotId: snapshot.id,
       buildDurationMs: snapshot.buildDurationMs,
       generatedAt: snapshot.generatedAt,
       buildStartedAt: null,
-      buildSandboxName: null,
+      buildPhase: null,
       buildCommandId: null,
       buildError: null,
-      createdAt: now,
       updatedAt: now
-    });
+    }).where(
+      and4(
+        eq4(juniorSnapshots.id, options.buildId),
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
+        eq4(juniorSnapshots.status, "building")
+      )
+    ).returning({ id: juniorSnapshots.id });
+    if (updated.length === 0) {
+      return { written: false, replacedBuilderNames: [] };
+    }
+    const replaced = await db.delete(juniorSnapshots).where(
+      and4(
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, snapshot.profileHash),
+        ne(juniorSnapshots.id, options.buildId),
+        or(
+          eq4(juniorSnapshots.status, "failed"),
+          eq4(juniorSnapshots.status, "ready")
+        )
+      )
+    ).returning({ sandboxName: juniorSnapshots.buildSandboxName });
+    return {
+      written: true,
+      replacedBuilderNames: builderNames(replaced)
+    };
   });
 }
-async function recordResolvedWorkspaceSnapshot(workspaceId, snapshot) {
-  if (!snapshot.snapshotId || !snapshot.profileHash || snapshot.createdAtMs == null || snapshot.buildDurationMs == null) {
-    return;
-  }
-  try {
-    await setWorkspaceSnapshot(workspaceId, {
-      id: snapshot.snapshotId,
-      generatedAt: new Date(snapshot.createdAtMs),
-      buildDurationMs: snapshot.buildDurationMs,
-      profileHash: snapshot.profileHash
-    });
-  } catch (error) {
-    logException(error, "sandbox.workspace_snapshot.persist.failed", {
-      "app.workspace.id": workspaceId
-    });
-  }
+async function setWorkspaceSnapshotBuild(workspaceId, build, options = {}) {
+  const executor = getSqlExecutor();
+  return await executor.transaction(async () => {
+    const db = executor.db();
+    const now = /* @__PURE__ */ new Date();
+    const updated = await db.update(juniorSnapshots).set({
+      status: build.status,
+      buildStartedAt: build.startedAt,
+      buildPhase: build.phase,
+      buildSandboxName: build.sandboxName,
+      buildCommandId: build.commandId,
+      buildError: build.error,
+      updatedAt: now
+    }).where(
+      and4(
+        eq4(juniorSnapshots.id, build.id),
+        eq4(juniorSnapshots.workspaceId, workspaceId),
+        eq4(juniorSnapshots.profileHash, build.profileHash),
+        eq4(juniorSnapshots.status, "building")
+      )
+    ).returning({ id: juniorSnapshots.id });
+    if (updated.length > 0) {
+      return true;
+    }
+    if (!options.insertIfMissing) return false;
+    const workspaceRows = await db.select({ setupScript: juniorWorkspaces.setupScript }).from(juniorWorkspaces).where(eq4(juniorWorkspaces.id, workspaceId)).for("update");
+    const workspace = workspaceRows[0];
+    if (!workspace) return false;
+    if (options.expectedRecipe) {
+      const repos = await db.select({
+        provider: juniorWorkspaceRepos.provider,
+        repo: juniorWorkspaceRepos.repo
+      }).from(juniorWorkspaceRepos).where(eq4(juniorWorkspaceRepos.workspaceId, workspaceId));
+      if (!sameWorkspaceRecipe({ ...workspace, repos }, options.expectedRecipe)) {
+        return false;
+      }
+    }
+    const inserted = await db.insert(juniorSnapshots).values({
+      id: build.id,
+      workspaceId,
+      profileHash: build.profileHash,
+      status: build.status,
+      snapshotId: null,
+      buildDurationMs: null,
+      generatedAt: null,
+      buildStartedAt: build.startedAt,
+      buildPhase: build.phase,
+      buildSandboxName: build.sandboxName,
+      buildCommandId: build.commandId,
+      buildError: build.error,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoNothing().returning({ id: juniorSnapshots.id });
+    return inserted.length > 0;
+  });
 }
 
 // src/chat/workspaces/validation.ts
@@ -1914,8 +1999,8 @@ async function workspaceWithSnapshot(db, row, repos) {
 }
 async function loadWorkspaceRepos(db, workspaceId) {
   return await db.select().from(juniorWorkspaceRepos).where(eq5(juniorWorkspaceRepos.workspaceId, workspaceId)).orderBy(
-    asc2(juniorWorkspaceRepos.provider),
-    asc2(juniorWorkspaceRepos.repo)
+    asc3(juniorWorkspaceRepos.provider),
+    asc3(juniorWorkspaceRepos.repo)
   );
 }
 async function replaceWorkspaceRepos(db, workspaceId, repos) {
@@ -1946,13 +2031,24 @@ function isUniqueViolation(error) {
   }
   return false;
 }
+async function cleanupSnapshotBuilders(workspaceId, names) {
+  if (names.length === 0) return;
+  try {
+    await deleteWorkspaceSnapshotBuilders(names);
+  } catch (error) {
+    logException(error, "sandbox.workspace_snapshot.builder.delete_failed", {
+      "app.workspace.id": workspaceId,
+      "app.sandbox.snapshot.builder_count": names.length
+    });
+  }
+}
 async function listWorkspaces(db) {
   const [workspaces, repos] = await Promise.all([
-    db.select().from(juniorWorkspaces).orderBy(asc2(juniorWorkspaces.name)),
+    db.select().from(juniorWorkspaces).orderBy(asc3(juniorWorkspaces.name)),
     db.select().from(juniorWorkspaceRepos).orderBy(
-      asc2(juniorWorkspaceRepos.workspaceId),
-      asc2(juniorWorkspaceRepos.provider),
-      asc2(juniorWorkspaceRepos.repo)
+      asc3(juniorWorkspaceRepos.workspaceId),
+      asc3(juniorWorkspaceRepos.provider),
+      asc3(juniorWorkspaceRepos.repo)
     )
   ]);
   return workspaces.map(
@@ -1975,7 +2071,7 @@ async function listWorkspaceNamesByRepository(db, input) {
       // Recipes store the provided repo casing; identity is case-insensitive.
       sql2`lower(${juniorWorkspaceRepos.repo}) = lower(${repo})`
     )
-  ).orderBy(asc2(juniorWorkspaces.name));
+  ).orderBy(asc3(juniorWorkspaces.name));
   return rows.map((row) => row.name);
 }
 async function getWorkspaceByName(db, name) {
@@ -2002,7 +2098,7 @@ async function createWorkspace(input) {
   const recipe = normalizeWorkspaceRecipe(input);
   const executor = getSqlExecutor();
   const now = /* @__PURE__ */ new Date();
-  const id = randomUUID3();
+  const id = randomUUID2();
   try {
     await executor.transaction(async () => {
       const db = executor.db();
@@ -2030,7 +2126,7 @@ async function updateWorkspace(id, input) {
   const executor = getSqlExecutor();
   const now = /* @__PURE__ */ new Date();
   try {
-    const updated = await executor.transaction(async () => {
+    const result = await executor.transaction(async () => {
       const db = executor.db();
       const existingRows = await db.select().from(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).limit(1);
       const existing = existingRows[0];
@@ -2043,12 +2139,11 @@ async function updateWorkspace(id, input) {
         updatedAt: now
       }).where(eq5(juniorWorkspaces.id, id)).returning();
       await replaceWorkspaceRepos(db, id, recipe.repos);
-      if (snapshotChanged) {
-        await clearNonReadySnapshots(db, id);
-      }
-      return rows[0];
+      const builderNames2 = snapshotChanged ? await clearWorkspaceSnapshots(db, id) : [];
+      return { builderNames: builderNames2, workspace: rows[0] };
     });
-    if (!updated) return void 0;
+    if (!result) return void 0;
+    await cleanupSnapshotBuilders(id, result.builderNames);
   } catch (error) {
     if (isUniqueViolation(error)) {
       throw new WorkspaceValidationError(
@@ -2061,10 +2156,14 @@ async function updateWorkspace(id, input) {
 }
 async function deleteWorkspace(id) {
   const executor = getSqlExecutor();
-  return await executor.transaction(async () => {
-    const rows = await executor.db().delete(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).returning({ id: juniorWorkspaces.id });
-    return rows.length > 0;
+  const result = await executor.transaction(async () => {
+    const db = executor.db();
+    const builderNames2 = await clearWorkspaceSnapshots(db, id);
+    const rows = await db.delete(juniorWorkspaces).where(eq5(juniorWorkspaces.id, id)).returning({ id: juniorWorkspaces.id });
+    return { builderNames: builderNames2, deleted: rows.length > 0 };
   });
+  await cleanupSnapshotBuilders(id, result.builderNames);
+  return result.deleted;
 }
 
 // src/chat/plugins/agent-hooks.ts
@@ -3341,8 +3440,13 @@ export {
   resolveChannelCapabilities,
   tryWorkspaceRepoCheckoutPath,
   workspaceRepoCheckoutPath,
+  getWorkspaceSnapshotBuilder,
+  deleteWorkspaceSnapshotBuilders,
   SANDBOX_RUNTIME,
-  recordResolvedWorkspaceSnapshot,
+  loadSnapshotsForProfile,
+  invalidateReadySnapshot,
+  setWorkspaceSnapshot,
+  setWorkspaceSnapshotBuild,
   WorkspaceValidationError,
   listWorkspaces,
   getWorkspaceByName,

package/dist/{chunk-VGDOEKO2.js → chunk-3TM3FYLQ.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-6NZRKJWU.js → chunk-4GWXAILB.js}

@@ -1,7 +1,7 @@
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 
 // src/chat/runtime/request-deadline.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-LFZODSAY.js → chunk-5IRROPA5.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-LPMLAJYR.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-VGDOEKO2.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   getChatConfig
-} from "./chunk-DLTP6TUJ.js";
+} from "./chunk-GENV6KF2.js";
 import {
   parseStoredSlackActor
 } from "./chunk-M63DETLL.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-7CVYXUOJ.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";