@sentry/junior 0.7.0 → 0.9.0

package/dist/handlers/webhooks.js

@@ -1,7 +1,7 @@
 import {
   POST
-} from "../chunk-QHKQ2AWX.js";
-import "../chunk-PY4AI2GZ.js";
+} from "../chunk-I3DYWLM6.js";
+import "../chunk-ZW4OVKF5.js";
 export {
   POST
 };

package/dist/next-config.js

@@ -2,7 +2,7 @@ import {
   discoverInstalledPluginPackageContent,
   discoverNodeModulesDirs,
   isDirectory
-} from "./chunk-Z5E25LRN.js";
+} from "./chunk-KCLEEKYX.js";
 
 // src/next-config.ts
 import { createRequire } from "module";

package/dist/production-XMCJXOOI.js

@@ -0,0 +1,15 @@
+import {
+  bot,
+  createNormalizingStream,
+  slackRuntime
+} from "./chunk-DIMXJUSL.js";
+import "./chunk-VM3CPAZF.js";
+import "./chunk-IJVZEV3K.js";
+import "./chunk-ZBWWHP6Q.js";
+import "./chunk-KCLEEKYX.js";
+import "./chunk-ZW4OVKF5.js";
+export {
+  bot,
+  createNormalizingStream,
+  slackRuntime
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,16 +27,17 @@
     "@chat-adapter/slack": "4.20.2",
     "@chat-adapter/state-memory": "4.20.2",
     "@chat-adapter/state-redis": "4.20.2",
-    "@mariozechner/pi-agent-core": "^0.56.3",
-    "@mariozechner/pi-ai": "^0.56.3",
+    "@mariozechner/pi-agent-core": "^0.59.0",
+    "@mariozechner/pi-ai": "^0.59.0",
+    "@modelcontextprotocol/sdk": "1.27.1",
     "@sinclair/typebox": "^0.34.48",
-    "@slack/web-api": "^7.14.1",
-    "@vercel/queue": "^0.1.3",
-    "@vercel/sandbox": "^1.8.0",
+    "@slack/web-api": "^7.15.0",
+    "@vercel/queue": "^0.1.4",
+    "@vercel/sandbox": "^1.8.1",
     "ai": "^6.0.116",
     "bash-tool": "^1.3.15",
     "chat": "4.20.2",
-    "just-bash": "^2.12.0",
+    "just-bash": "^2.13.1",
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
@@ -48,26 +49,23 @@
     "react-dom": ">=19.0.0"
   },
   "devDependencies": {
-    "@sentry/nextjs": "^10.42.0",
+    "@sentry/nextjs": "^10.44.0",
     "@types/node": "^25.3.5",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "msw": "^2.12.10",
-    "next": "^16.1.6",
+    "msw": "^2.12.13",
+    "next": "^16.1.7",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "vercel": "^50.28.0",
-    "vitest": "^4.0.18",
-    "vitest-evals": "^0.6.0"
+    "vercel": "^50.32.5",
+    "vitest": "^4.1.0"
   },
   "scripts": {
     "build": "tsup",
     "test": "pnpm run test:slack-boundary && vitest run",
     "test:watch": "vitest",
-    "preevals": "pnpm run test:slack-boundary",
-    "evals": "JUNIOR_STATE_ADAPTER=memory pnpm exec vitest run -c vitest.evals.config.ts",
     "test:slack-boundary": "node scripts/check-slack-test-boundary.mjs",
     "typecheck": "tsc --noEmit",
     "skills:check": "node scripts/check-skills.mjs"

package/dist/bot-ZKMCCT3D.js

@@ -1,19 +0,0 @@
-import {
-  appSlackRuntime,
-  bot,
-  createNormalizingStream,
-  resetBotDepsForTests,
-  setBotDepsForTests
-} from "./chunk-JRKU55W5.js";
-import "./chunk-KT5HARSN.js";
-import "./chunk-RKOO42TW.js";
-import "./chunk-Z5E25LRN.js";
-import "./chunk-PY4AI2GZ.js";
-import "./chunk-VW26MOSO.js";
-export {
-  appSlackRuntime,
-  bot,
-  createNormalizingStream,
-  resetBotDepsForTests,
-  setBotDepsForTests
-};

package/dist/chunk-56WI5Q7P.js

@@ -1,330 +0,0 @@
-import {
-  appSlackRuntime,
-  createQueueCallbackHandler,
-  downloadPrivateSlackFile,
-  getThreadMessageTopic,
-  removeReactionFromMessage
-} from "./chunk-JRKU55W5.js";
-import {
-  acquireQueueMessageProcessingOwnership,
-  completeQueueMessageProcessingOwnership,
-  failQueueMessageProcessingOwnership,
-  getQueueMessageProcessingState,
-  getStateAdapter,
-  refreshQueueMessageProcessingOwnership
-} from "./chunk-RKOO42TW.js";
-import {
-  createRequestContext,
-  logError,
-  logException,
-  logInfo,
-  logWarn,
-  setSpanStatus,
-  withContext,
-  withSpan
-} from "./chunk-PY4AI2GZ.js";
-
-// src/chat/queue/process-thread-message.ts
-import { Message, ThreadImpl } from "chat";
-
-// src/chat/thread-runtime/process-thread-message-runtime.ts
-function rehydrateAttachmentFetchers(payload) {
-  for (const attachment of payload.message.attachments) {
-    if (!attachment.fetchData && attachment.url) {
-      attachment.fetchData = () => downloadPrivateSlackFile(attachment.url);
-    }
-  }
-}
-async function processThreadMessageRuntime(args) {
-  const runtimePayload = {
-    message: args.message,
-    thread: args.thread
-  };
-  rehydrateAttachmentFetchers(runtimePayload);
-  if (args.kind === "new_mention") {
-    await appSlackRuntime.handleNewMention(args.thread, args.message, {
-      beforeFirstResponsePost: args.beforeFirstResponsePost
-    });
-    return;
-  }
-  if (args.kind === "subscribed_reply") {
-    await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
-      beforeFirstResponsePost: args.beforeFirstResponsePost,
-      preApprovedReply: true
-    });
-    return;
-  }
-  await appSlackRuntime.handleSubscribedMessage(args.thread, args.message, {
-    beforeFirstResponsePost: args.beforeFirstResponsePost
-  });
-}
-
-// src/chat/queue/process-thread-message.ts
-var stateAdapterConnected = false;
-function isSerializedThread(thread) {
-  return typeof thread === "object" && thread !== null && thread._type === "chat:Thread";
-}
-function isSerializedMessage(message) {
-  return typeof message === "object" && message !== null && message._type === "chat:Message";
-}
-function getPayloadChannelId(payload) {
-  return payload.thread.channelId;
-}
-function getPayloadUserId(payload) {
-  return payload.message.author?.userId;
-}
-function createMessageOwnerToken() {
-  return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}
-var QueueMessageOwnershipError = class extends Error {
-  constructor(stage, dedupKey) {
-    super(
-      `Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`
-    );
-    this.name = "QueueMessageOwnershipError";
-  }
-};
-var defaultProcessQueuedThreadMessageDeps = {
-  clearProcessingReaction: async ({ channelId, timestamp }) => {
-    await removeReactionFromMessage({
-      channelId,
-      timestamp,
-      emoji: "eyes"
-    });
-  },
-  logInfo,
-  logWarn,
-  processRuntime: processThreadMessageRuntime
-};
-function deserializeThread(thread) {
-  if (isSerializedThread(thread)) {
-    return ThreadImpl.fromJSON(thread);
-  }
-  return thread;
-}
-function deserializeMessage(message) {
-  if (isSerializedMessage(message)) {
-    return Message.fromJSON(message);
-  }
-  return message;
-}
-async function logThreadMessageFailure(payload, errorMessage) {
-  logError(
-    "queue_message_failed",
-    {
-      slackThreadId: payload.normalizedThreadId,
-      slackChannelId: getPayloadChannelId(payload),
-      slackUserId: getPayloadUserId(payload)
-    },
-    {
-      "messaging.message.id": payload.message.id,
-      "app.queue.message_kind": payload.kind,
-      "app.queue.message_id": payload.queueMessageId,
-      "error.message": errorMessage
-    },
-    "Queue message processing failed"
-  );
-}
-async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedThreadMessageDeps) {
-  const existingMessageState = await getQueueMessageProcessingState(
-    payload.dedupKey
-  );
-  if (existingMessageState?.status === "completed") {
-    deps.logInfo(
-      "queue_message_skipped_completed",
-      {
-        slackThreadId: payload.normalizedThreadId,
-        slackChannelId: getPayloadChannelId(payload),
-        slackUserId: getPayloadUserId(payload)
-      },
-      {
-        "messaging.message.id": payload.message.id,
-        "app.queue.message_kind": payload.kind,
-        "app.queue.message_id": payload.queueMessageId,
-        "app.queue.processing_state": existingMessageState.status
-      },
-      "Skipping queue message because it is already completed"
-    );
-    return;
-  }
-  const ownerToken = createMessageOwnerToken();
-  const claimResult = await acquireQueueMessageProcessingOwnership({
-    rawKey: payload.dedupKey,
-    ownerToken,
-    queueMessageId: payload.queueMessageId
-  });
-  if (claimResult === "blocked") {
-    deps.logInfo(
-      "queue_message_skipped_blocked",
-      {
-        slackThreadId: payload.normalizedThreadId,
-        slackChannelId: getPayloadChannelId(payload),
-        slackUserId: getPayloadUserId(payload)
-      },
-      {
-        "messaging.message.id": payload.message.id,
-        "app.queue.message_kind": payload.kind,
-        "app.queue.message_id": payload.queueMessageId,
-        "app.queue.claim_result": claimResult,
-        "app.queue.processing_state": "processing"
-      },
-      "Skipping queue message because another worker owns it"
-    );
-    return;
-  }
-  const threadWasSerialized = isSerializedThread(payload.thread);
-  if (threadWasSerialized && !stateAdapterConnected) {
-    await getStateAdapter().connect();
-    stateAdapterConnected = true;
-  }
-  const runtimePayload = {
-    ...payload,
-    thread: deserializeThread(payload.thread),
-    message: deserializeMessage(payload.message)
-  };
-  let reactionCleared = false;
-  const clearProcessingReaction = async () => {
-    if (reactionCleared) {
-      return;
-    }
-    reactionCleared = true;
-    try {
-      await deps.clearProcessingReaction({
-        channelId: runtimePayload.thread.channelId,
-        timestamp: runtimePayload.message.id
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      deps.logWarn(
-        "queue_processing_reaction_clear_failed",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: getPayloadChannelId(payload),
-          slackUserId: getPayloadUserId(payload)
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "error.message": errorMessage
-        },
-        "Failed to remove processing reaction after queue turn completion"
-      );
-    }
-  };
-  try {
-    const refreshed = await refreshQueueMessageProcessingOwnership({
-      rawKey: payload.dedupKey,
-      ownerToken,
-      queueMessageId: payload.queueMessageId
-    });
-    if (!refreshed) {
-      throw new QueueMessageOwnershipError("refresh", payload.dedupKey);
-    }
-    await deps.processRuntime({
-      kind: runtimePayload.kind,
-      thread: runtimePayload.thread,
-      message: runtimePayload.message
-    });
-    await clearProcessingReaction();
-    const completed = await completeQueueMessageProcessingOwnership({
-      rawKey: payload.dedupKey,
-      ownerToken,
-      queueMessageId: payload.queueMessageId
-    });
-    if (!completed) {
-      throw new QueueMessageOwnershipError("complete", payload.dedupKey);
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    await clearProcessingReaction();
-    await logThreadMessageFailure(payload, errorMessage);
-    const failed = await failQueueMessageProcessingOwnership({
-      rawKey: payload.dedupKey,
-      ownerToken,
-      errorMessage,
-      queueMessageId: payload.queueMessageId
-    });
-    if (!failed && !(error instanceof QueueMessageOwnershipError)) {
-      throw new Error(
-        `Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`
-      );
-    }
-    throw error;
-  }
-}
-
-// src/handlers/queue-callback.ts
-var callbackHandler = createQueueCallbackHandler(
-  async (message, metadata) => {
-    if (metadata.topicName === getThreadMessageTopic()) {
-      const payload = {
-        ...message,
-        queueMessageId: metadata.messageId
-      };
-      logInfo(
-        "queue_callback_received",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: payload.thread.channelId,
-          slackUserId: payload.message.author?.userId
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.queue.delivery_count": metadata.deliveryCount,
-          "app.queue.topic": metadata.topicName
-        },
-        "Received queue callback payload"
-      );
-      await withSpan(
-        "queue.process_message",
-        "queue.process_message",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: payload.thread.channelId,
-          slackUserId: payload.message.author?.userId
-        },
-        async () => {
-          await processQueuedThreadMessage(payload);
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.queue.delivery_count": metadata.deliveryCount,
-          "app.queue.topic": metadata.topicName
-        }
-      );
-      return;
-    }
-    throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
-  }
-);
-async function POST(request) {
-  const requestContext = createRequestContext(request, { platform: "queue" });
-  return withContext(requestContext, async () => {
-    try {
-      const response = await callbackHandler(request);
-      setSpanStatus(response.status >= 500 ? "error" : "ok");
-      return response;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logError(
-        "queue_callback_failed",
-        {},
-        {
-          "error.message": message
-        },
-        "Queue callback processing failed"
-      );
-      logException(error, "queue_callback_failed");
-      throw error;
-    }
-  });
-}
-
-export {
-  POST
-};

package/dist/chunk-KT5HARSN.js

@@ -1,164 +0,0 @@
-// src/chat/skill-frontmatter.ts
-import { z } from "zod";
-import { parse as parseYaml } from "yaml";
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-var SKILL_NAME_RE = /^[a-z0-9-]+$/;
-var CAPABILITY_TOKEN_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
-var MAX_NAME_LENGTH = 64;
-var MAX_DESCRIPTION_LENGTH = 1024;
-var MAX_COMPATIBILITY_LENGTH = 500;
-function hasAngleBrackets(value) {
-  return value.includes("<") || value.includes(">");
-}
-function validateSkillName(name) {
-  if (!name) return "name must not be empty";
-  if (name.length > MAX_NAME_LENGTH)
-    return `name must be <= ${MAX_NAME_LENGTH} characters`;
-  if (!SKILL_NAME_RE.test(name))
-    return "name must contain only lowercase letters, digits, and hyphens";
-  if (name.startsWith("-") || name.endsWith("-"))
-    return "name must not start or end with a hyphen";
-  if (name.includes("--")) return "name must not contain consecutive hyphens";
-  return null;
-}
-function createTokenFieldSchema(fieldName, example) {
-  return z.string({
-    error: `Frontmatter field "${fieldName}" must be a string when present`
-  }).superRefine((value, ctx) => {
-    const tokens = value.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-    for (const token of tokens) {
-      if (!CAPABILITY_TOKEN_RE.test(token)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `${fieldName} token "${token}" is invalid; expected dotted lowercase tokens (for example "${example}")`
-        });
-        return;
-      }
-    }
-  });
-}
-function parseTokenList(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const tokens = value.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 0);
-  return tokens.length > 0 ? tokens : void 0;
-}
-var skillFrontmatterSchema = z.object({
-  name: z.string({ error: 'Frontmatter field "name" must be a string' }).superRefine((value, ctx) => {
-    const nameError = validateSkillName(value);
-    if (nameError) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: nameError
-      });
-    }
-  }),
-  description: z.string({ error: 'Frontmatter field "description" must be a string' }).superRefine((value, ctx) => {
-    if (!value.trim()) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "description must not be empty"
-      });
-      return;
-    }
-    if (value.length > MAX_DESCRIPTION_LENGTH) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `description must be <= ${MAX_DESCRIPTION_LENGTH} characters`
-      });
-      return;
-    }
-    if (hasAngleBrackets(value)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: 'description must not contain "<" or ">"'
-      });
-    }
-  }),
-  metadata: z.record(z.string(), z.unknown(), {
-    error: 'Frontmatter field "metadata" must be an object when present'
-  }).optional(),
-  compatibility: z.string({
-    error: 'Frontmatter field "compatibility" must be a string when present'
-  }).superRefine((value, ctx) => {
-    if (value.length > MAX_COMPATIBILITY_LENGTH) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `compatibility must be <= ${MAX_COMPATIBILITY_LENGTH} characters`
-      });
-    }
-  }).optional(),
-  license: z.string({
-    error: 'Frontmatter field "license" must be a string when present'
-  }).optional(),
-  "allowed-tools": z.string({
-    error: 'Frontmatter field "allowed-tools" must be a string when present'
-  }).optional(),
-  "requires-capabilities": createTokenFieldSchema(
-    "requires-capabilities",
-    "github.issues.write"
-  ).optional(),
-  "uses-config": createTokenFieldSchema(
-    "uses-config",
-    "github.repo"
-  ).optional()
-}).passthrough();
-function stripFrontmatter(raw) {
-  return raw.replace(FRONTMATTER_RE, "").trim();
-}
-function parseSkillFile(raw, expectedName) {
-  const match = FRONTMATTER_RE.exec(raw);
-  if (!match) {
-    return { ok: false, error: "Missing YAML frontmatter at start of file" };
-  }
-  let parsed;
-  try {
-    parsed = parseYaml(match[1]);
-  } catch (error) {
-    return {
-      ok: false,
-      error: `Invalid YAML frontmatter: ${error instanceof Error ? error.message : String(error)}`
-    };
-  }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return { ok: false, error: "Frontmatter must be a YAML object" };
-  }
-  const result = skillFrontmatterSchema.safeParse(parsed);
-  if (!result.success) {
-    return {
-      ok: false,
-      error: result.error.issues[0]?.message ?? "Invalid YAML frontmatter"
-    };
-  }
-  if (expectedName && result.data.name !== expectedName) {
-    return {
-      ok: false,
-      error: `name "${result.data.name}" must match directory "${expectedName}"`
-    };
-  }
-  const allowedTools = parseTokenList(result.data["allowed-tools"]);
-  const requiresCapabilities = parseTokenList(
-    result.data["requires-capabilities"]
-  );
-  const usesConfig = parseTokenList(result.data["uses-config"]);
-  return {
-    ok: true,
-    skill: {
-      name: result.data.name,
-      description: result.data.description,
-      body: stripFrontmatter(raw),
-      ...result.data.metadata ? { metadata: result.data.metadata } : {},
-      ...result.data.compatibility !== void 0 ? { compatibility: result.data.compatibility } : {},
-      ...result.data.license !== void 0 ? { license: result.data.license } : {},
-      ...allowedTools ? { allowedTools } : {},
-      ...requiresCapabilities ? { requiresCapabilities } : {},
-      ...usesConfig ? { usesConfig } : {}
-    }
-  };
-}
-
-export {
-  stripFrontmatter,
-  parseSkillFile
-};