@sentry/junior 0.110.0 → 0.112.0

package/dist/{chunk-W6RJZG7F.js → chunk-66IP6WED.js}

@@ -1,19 +1,21 @@
 import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter
-} from "./chunk-GK47NBDE.js";
+} from "./chunk-X3SP5RDW.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
 import {
   toOptionalTrimmed
-} from "./chunk-WNOVRQ67.js";
+} from "./chunk-PK4ETCUQ.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3TV7OEHL.js";
+} from "./chunk-ZHP4KNF7.js";
 import {
+  setSpanAttributes,
+  setSpanStatus,
   withSpan
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-CSS7JHEM.js";
 
 // src/chat/sandbox/runtime-dependencies.ts
 var GLOBAL_RUNTIME_DEPENDENCIES = [
@@ -105,37 +107,303 @@ function getVercelSandboxCredentials() {
 }
 
 // src/chat/sandbox/workspace.ts
-function createSandboxInstance(sandbox) {
+import {
+  FileSystem
+} from "@vercel/sandbox";
+
+// src/chat/sandbox/http-error-details.ts
+var DEFAULT_PREVIEW_LIMIT = 512;
+function toTrimmedString(value, maxChars) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}\u2026` : normalized;
+}
+function extractHttpErrorDetails(error, options = {}) {
+  const prefix = options.attributePrefix ?? "app.http_error";
+  const previewLimit = options.previewLimit ?? DEFAULT_PREVIEW_LIMIT;
+  const normalizedError = error instanceof Error ? error : new Error(String(error));
+  const err = error ?? {};
+  const attributes = {
+    "error.type": normalizedError.name || "Error",
+    "exception.message": toTrimmedString(normalizedError.message, previewLimit) ?? "HTTP error"
+  };
+  const response = err.response;
+  const statusCode = typeof response?.status === "number" ? response.status : void 0;
+  const statusText = toTrimmedString(response?.statusText, previewLimit);
+  const responseUrl = toTrimmedString(response?.url, previewLimit);
+  const responseText = toTrimmedString(err.text, previewLimit);
+  const responseJson = toTrimmedString(
+    err.json && typeof err.json === "object" ? JSON.stringify(err.json) : void 0,
+    previewLimit
+  );
+  const contentType = toTrimmedString(
+    response?.headers?.get?.("content-type"),
+    previewLimit
+  );
+  const requestIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-request-id"),
+    previewLimit
+  );
+  const vercelIdHeader = toTrimmedString(
+    response?.headers?.get?.("x-vercel-id"),
+    previewLimit
+  );
+  const requestId = requestIdHeader ?? vercelIdHeader;
+  if (statusCode !== void 0) {
+    attributes["http.response.status_code"] = statusCode;
+  }
+  if (statusText) {
+    attributes[`${prefix}.status_text`] = statusText;
+  }
+  if (responseUrl) {
+    attributes["url.full"] = responseUrl;
+  }
+  if (contentType) {
+    attributes["http.response.header.content-type"] = [contentType];
+  }
+  if (requestIdHeader) {
+    attributes["http.response.header.x-request-id"] = [requestIdHeader];
+  }
+  if (vercelIdHeader) {
+    attributes["http.response.header.x-vercel-id"] = [vercelIdHeader];
+  }
+  if (responseText) {
+    attributes[`${prefix}.response_text_preview`] = responseText;
+    attributes[`${prefix}.response_text_length`] = responseText.length;
+  }
+  if (responseJson) {
+    attributes[`${prefix}.response_json_preview`] = responseJson;
+  }
+  const summaryParts = [];
+  if (statusCode !== void 0) {
+    summaryParts.push(`status=${statusCode}`);
+  }
+  if (statusText) {
+    summaryParts.push(`statusText=${statusText}`);
+  }
+  if (responseUrl) {
+    summaryParts.push(`url=${responseUrl}`);
+  }
+  if (requestId) {
+    summaryParts.push(`requestId=${requestId}`);
+  }
+  for (const field of options.extraFields ?? []) {
+    const value = toTrimmedString(err[field.sourceKey], previewLimit);
+    if (!value) {
+      continue;
+    }
+    attributes[`${prefix}.${field.attributeKey}`] = value;
+    summaryParts.push(`${field.summaryKey ?? field.attributeKey}=${value}`);
+  }
+  if (responseJson) {
+    summaryParts.push(`json=${responseJson}`);
+  } else if (responseText) {
+    summaryParts.push(`text=${responseText}`);
+  }
+  const searchableText = `${normalizedError.message} ${responseText ?? ""} ${responseJson ?? ""}`.toLowerCase();
+  return {
+    attributes,
+    summary: summaryParts.join(", "),
+    searchableText
+  };
+}
+
+// src/chat/sandbox/errors.ts
+var SANDBOX_ERROR_FIELDS = [
+  {
+    sourceKey: "sandboxId",
+    attributeKey: "sandbox_id",
+    summaryKey: "sandboxId"
+  }
+];
+function getSandboxErrorDetails(error) {
+  return extractHttpErrorDetails(error, {
+    attributePrefix: "app.sandbox.api_error",
+    extraFields: [...SANDBOX_ERROR_FIELDS]
+  });
+}
+function findInErrorChain(error, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (predicate(current)) {
+      return true;
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return false;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInvalidSandboxSessionError(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  if (isRecord(error.json) && error.json.invalidToken === true) {
+    return true;
+  }
+  const response = error.response;
+  return isRecord(response) && response.status === 403 && typeof response.url === "string" && response.url.includes("/sandboxes/sessions");
+}
+function getFirstErrorMessage(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (current instanceof Error) {
+      const message = current.message.trim();
+      if (message) {
+        return message;
+      }
+    }
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
+  }
+  return void 0;
+}
+function isAlreadyExistsError(error) {
+  const details = getSandboxErrorDetails(error);
+  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
+}
+function isSandboxUnavailableError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (isInvalidSandboxSessionError(candidate)) {
+      return true;
+    }
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available") || searchable.includes("stream was closed and is not accepting commands");
+  });
+}
+function isSandboxMissingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("status=404") || searchable.includes("status code 404") || searchable.includes("snapshot_not_found");
+  });
+}
+function isSnapshottingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
+  });
+}
+function isSandboxCommandStreamInterruptedError(error) {
+  return findInErrorChain(error, (candidate) => {
+    if (!(candidate instanceof Error)) {
+      return false;
+    }
+    return candidate.name === "StreamError" && candidate.message.toLowerCase().includes("stream ended before command finished");
+  });
+}
+function wrapSandboxSetupError(error) {
+  try {
+    const details = getSandboxErrorDetails(error);
+    if (details.summary) {
+      return new Error(`sandbox setup failed (${details.summary})`, {
+        cause: error
+      });
+    }
+  } catch {
+  }
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
+  }
+  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
+    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
+    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  }
+  return new Error("sandbox setup failed", { cause: error });
+}
+function throwSandboxOperationError(action, error, includeMissingPath = false) {
+  const details = getSandboxErrorDetails(error);
+  setSpanAttributes({
+    ...details.attributes,
+    ...includeMissingPath ? {
+      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
+    } : {},
+    "app.sandbox.success": false
+  });
+  setSpanStatus("error");
+  throw new Error(
+    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
+    {
+      cause: error
+    }
+  );
+}
+
+// src/chat/sandbox/workspace.ts
+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 (filePath, readOptions) => await run(async () => await fileSystem.readFile(filePath, readOptions)),
+    writeFile: async (filePath, content, writeOptions) => await run(
+      async () => await fileSystem.writeFile(filePath, content, writeOptions)
+    ),
+    readdir: async (filePath) => await run(async () => await fileSystem.readdir(filePath)),
+    stat: async (filePath) => await run(async () => await fileSystem.stat(filePath))
+  };
   return {
     sandboxId: sandbox.name,
-    get sandboxEgressId() {
-      return sandbox.currentSession().sessionId;
-    },
-    fs: sandbox.fs,
+    sessionId: session.sessionId,
+    fs,
     extendTimeout(duration) {
-      return sandbox.extendTimeout(duration);
+      return run(async () => await session.extendTimeout(duration));
     },
     mkDir(path) {
-      return sandbox.mkDir(path);
+      return run(async () => await session.mkDir(path));
     },
     readFileToBuffer(input) {
-      return sandbox.readFileToBuffer(input);
+      return run(async () => await session.readFileToBuffer(input));
     },
-    runCommand(input) {
-      return sandbox.runCommand(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
+      };
     },
-    async snapshot() {
-      const snapshot = await sandbox.snapshot();
-      return { snapshotId: snapshot.snapshotId };
+    snapshot() {
+      return run(async () => {
+        const snapshot = await session.snapshot();
+        return { snapshotId: snapshot.snapshotId };
+      });
     },
     stop() {
-      return sandbox.stop();
+      return run(async () => await session.stop());
     },
     update(params) {
-      return sandbox.update(params);
+      return run(async () => await session.update(params));
     },
     writeFiles(files) {
-      return sandbox.writeFiles(files);
+      return run(async () => await session.writeFiles(files));
     }
   };
 }
@@ -258,8 +526,8 @@ async function runOrThrow(sandbox, params, label) {
   if (result.exitCode === 0) {
     return;
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   const detail = stderr || stdout || "command failed";
   throw new Error(`${label} failed: ${detail}`);
 }
@@ -268,8 +536,8 @@ async function tryRun(sandbox, params) {
   if (result.exitCode === 0) {
     return { ok: true };
   }
-  const stderr = (await result.stderr()).trim();
-  const stdout = (await result.stdout()).trim();
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
   return { ok: false, detail: stderr || stdout || "command failed" };
 }
 async function installGhCliViaDnf(sandbox) {
@@ -368,8 +636,8 @@ async function installRuntimeDependencies(sandbox, deps) {
               cmd: "sha256sum",
               args: [rpmPath]
             });
-            const checksumStdout = (await checksumResult.stdout()).trim();
-            const checksumStderr = (await checksumResult.stderr()).trim();
+            const checksumStdout = checksumResult.stdout.trim();
+            const checksumStderr = checksumResult.stderr.trim();
             if (checksumResult.exitCode !== 0) {
               throw new Error(
                 `sha256sum failed: ${checksumStderr || checksumStdout || "command failed"}`
@@ -460,8 +728,8 @@ async function runRuntimePostinstall(sandbox, commands) {
         if (result.exitCode === 0) {
           continue;
         }
-        const stderr = (await result.stderr()).trim();
-        const stdout = (await result.stdout()).trim();
+        const stderr = result.stderr.trim();
+        const stdout = result.stdout.trim();
         const detail = stderr || stdout || "command failed";
         throw new Error(`runtime-postinstall ${command.cmd} failed: ${detail}`);
       }
@@ -479,7 +747,7 @@ async function createDependencySnapshot(profile, runtime, timeoutMs) {
     async () => {
       const sandboxCredentials = getVercelSandboxCredentials();
       const resources = getSandboxResources();
-      const sandbox = createSandboxInstance(
+      const sandbox = createSandboxSession(
         await Sandbox.create({
           timeout: timeoutMs,
           runtime,
@@ -697,12 +965,19 @@ function isSnapshotMissingError(error) {
 }
 
 export {
+  isAlreadyExistsError,
+  isSandboxUnavailableError,
+  isSandboxMissingError,
+  isSnapshottingError,
+  isSandboxCommandStreamInterruptedError,
+  wrapSandboxSetupError,
+  throwSandboxOperationError,
+  getVercelSandboxCredentials,
   buildNonInteractiveShellScript,
   runNonInteractiveCommand,
-  getVercelSandboxCredentials,
   getSandboxResources,
   GLOBAL_RUNTIME_DEPENDENCIES,
-  createSandboxInstance,
+  createSandboxSession,
   getRuntimeDependencyProfileHash,
   resolveRuntimeDependencySnapshot,
   isSnapshotMissingError

package/dist/{chunk-W75ZPAGG.js → chunk-AU2JVUDF.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-ZKIOWEFL.js";
+} from "./chunk-IV2O4HQJ.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";

package/dist/{chunk-3UBQI73J.js → chunk-AWNDKI5K.js}

@@ -14,20 +14,20 @@ import {
   markTurnCompleted,
   mergeArtifactsState,
   updateConversationStats
-} from "./chunk-C5XAFTHY.js";
+} from "./chunk-SKEMI4IF.js";
 import {
   createPluginEmbedder,
   createPluginLogger,
   createPluginModel,
   createPluginState,
   getPlugins
-} from "./chunk-2T7TIEXI.js";
+} from "./chunk-VBSVNOLA.js";
 import {
   getStateAdapter
-} from "./chunk-GK47NBDE.js";
+} from "./chunk-X3SP5RDW.js";
 import {
   getDb
-} from "./chunk-4QU44P7Q.js";
+} from "./chunk-QIALGHRN.js";
 import {
   getPiMessageRole,
   instructionTextForProjection,
@@ -35,10 +35,10 @@ import {
   isToolResultMessage,
   normalizeToolNameFromResult,
   stripRuntimeTurnContext
-} from "./chunk-WNOVRQ67.js";
+} from "./chunk-PK4ETCUQ.js";
 import {
   buildTurnFailureResponse
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-CSS7JHEM.js";
 import {
   parseSlackMessageTs
 } from "./chunk-42WRQLJ6.js";
@@ -514,8 +514,7 @@ function buildDeliveredTurnStatePatch(args) {
   return {
     artifacts,
     conversation,
-    sandboxId: args.reply.sandboxId,
-    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+    sandboxRef: args.reply.sandboxRef
   };
 }
 

package/dist/{chunk-IYKPU7H6.js → chunk-CSS7JHEM.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-W75ZPAGG.js";
+} from "./chunk-AU2JVUDF.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/{chunk-SBOBTS27.js → chunk-GJG67YFS.js}

@@ -1,9 +1,9 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-3TV7OEHL.js";
+} from "./chunk-ZHP4KNF7.js";
 import {
   logWarn
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-CSS7JHEM.js";
 import {
   skillRoots
 } from "./chunk-3V7OFJZC.js";