@sentry/junior 0.179.0 → 0.180.0

package/dist/{chunk-XZY6G5YZ.js → chunk-CK6EINVZ.js}

@@ -2,10 +2,10 @@ import {
   ToolInputError,
   canRouteResourceEvents,
   getPlugins
-} from "./chunk-3I7XE3PA.js";
+} from "./chunk-DHLOGWYH.js";
 import {
   getDb
-} from "./chunk-VP4OVRDD.js";
+} from "./chunk-S7YRTOSQ.js";
 import {
   juniorAttachments,
   juniorConversations,
@@ -13,10 +13,16 @@ import {
   juniorSchedulerRuns,
   juniorSchedulerTasks,
   juniorStats
-} from "./chunk-R6U7N4FS.js";
+} from "./chunk-FGC3PHNH.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
+import {
+  getSlackBotToken
+} from "./chunk-I6IFTAPF.js";
+import {
+  logWarn
+} from "./chunk-RAZG3YHC.js";
 
 // src/chat/resource-events/catalog.ts
 import {
@@ -75,14 +81,15 @@ function normalizeEventIdentifier(catalog, namespace, identifier) {
 
 // src/chat/resource-events/runtime-catalog.ts
 function getResourceEventCatalog() {
+  if (!canRouteResourceEvents()) return {};
   return Object.fromEntries(
-    canRouteResourceEvents() ? getPlugins().flatMap((plugin) => {
+    getPlugins().flatMap((plugin) => {
       const registration = plugin.resourceEvents;
       if (!registration || registration.isEnabled?.() === false) {
         return [];
       }
       return [[plugin.manifest.name, registration]];
-    }) : []
+    })
   );
 }
 
@@ -91,15 +98,15 @@ import { and, asc, desc, eq, inArray, or, sql } from "drizzle-orm";
 
 // src/chat/event-tasks/types.ts
 import {
+  actorUserIdSchema,
   destinationVisibilitySchema,
   resourceEventTypeSchema,
-  slackActorSchema,
   slackDestinationSchema
 } from "@sentry/junior-plugin-api";
 import { z as z2 } from "zod";
 var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
 var eventTaskPrincipalSchema = z2.object({
-  slackUserId: slackActorSchema.shape.userId,
+  slackUserId: actorUserIdSchema,
   fullName: z2.string().optional(),
   userName: z2.string().optional()
 }).strict();
@@ -151,7 +158,7 @@ async function createEventTask(db, task) {
     title,
     task: parsed
   }).onConflictDoNothing();
-  return await getEventTask(db, parsed.id) ?? { ...parsed, ...title ? { title } : {} };
+  return await getEventTask(db, parsed.id) ?? { ...parsed, ...title ? { title } : void 0 };
 }
 async function saveEventTask(db, task) {
   const parsed = eventTaskSchema.parse(eventTaskJsonPayload(task));
@@ -305,34 +312,119 @@ function makeStructuredToolOutput(details, options = {}) {
   };
 }
 
-// src/chat/event-tasks/tool-support.ts
+// src/chat/slack/user.ts
 import { z as z4 } from "zod";
-var compactEventTaskResultSchema = z4.object({
-  id: z4.string().min(1),
-  task: z4.string().min(1),
-  namespace: z4.string().min(1),
-  identifier: z4.string().min(1),
-  resourceType: z4.string().min(1),
-  label: z4.string().min(1),
-  events: z4.array(z4.string().min(1)).min(1),
-  credentialMode: z4.enum(["system", "creator"]),
+var slackUserInfoSchema = z4.object({
+  ok: z4.literal(true),
+  user: z4.object({
+    name: z4.string().nullish(),
+    profile: z4.object({
+      email: z4.string().nullish(),
+      real_name: z4.string().nullish()
+    }).optional()
+  })
+});
+var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
+var userCache = /* @__PURE__ */ new Map();
+function userCacheKey(teamId, userId) {
+  return `${teamId}:${userId}`;
+}
+function readFromCache(teamId, userId) {
+  const hit = userCache.get(userCacheKey(teamId, userId));
+  if (!hit) return null;
+  if (hit.expiresAt < Date.now()) {
+    userCache.delete(userCacheKey(teamId, userId));
+    return null;
+  }
+  return hit.value;
+}
+function writeToCache(teamId, userId, value) {
+  userCache.set(userCacheKey(teamId, userId), {
+    value,
+    expiresAt: Date.now() + USER_CACHE_TTL_MS
+  });
+}
+async function lookupSlackUser(teamId, userId) {
+  if (!teamId || !userId) {
+    return null;
+  }
+  const cached = readFromCache(teamId, userId);
+  if (cached) {
+    return cached;
+  }
+  const token = getSlackBotToken();
+  if (!token) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`
+        }
+      }
+    );
+    if (!response.ok) {
+      logWarn("slack.user.lookup.failed", {
+        "enduser.id": userId,
+        "app.slack.team_id": teamId,
+        "http.response.status_code": response.status
+      });
+      return null;
+    }
+    const parsed = slackUserInfoSchema.safeParse(await response.json());
+    if (!parsed.success) {
+      return null;
+    }
+    const payload = parsed.data;
+    const userName = payload.user.name?.trim() || void 0;
+    const fullName = payload.user.profile?.real_name?.trim() || void 0;
+    const result = {
+      userName,
+      fullName,
+      email: payload.user.profile?.email?.trim() || void 0
+    };
+    writeToCache(teamId, userId, result);
+    return result;
+  } catch (error) {
+    logWarn("slack.user.lookup.failed", {
+      "enduser.id": userId,
+      "app.slack.team_id": teamId,
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+
+// src/chat/event-tasks/tool-support.ts
+import { z as z5 } from "zod";
+var compactEventTaskResultSchema = z5.object({
+  id: z5.string().min(1),
+  task: z5.string().min(1),
+  namespace: z5.string().min(1),
+  identifier: z5.string().min(1),
+  resourceType: z5.string().min(1),
+  label: z5.string().min(1),
+  events: z5.array(z5.string().min(1)).min(1),
+  credentialMode: z5.enum(["system", "creator"]),
   createdBy: eventTaskPrincipalSchema,
-  triggerAvailable: z4.boolean()
+  triggerAvailable: z5.boolean()
 }).strict();
 var eventTaskToolResultSchema = juniorToolOutputSchema.extend({
   task: compactEventTaskResultSchema
 }).strict();
 var eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
-  tasks: z4.array(compactEventTaskResultSchema),
-  truncated: z4.boolean()
+  tasks: z5.array(compactEventTaskResultSchema),
+  truncated: z5.boolean()
 }).strict();
 function registeredEventTaskTriggerSchema(catalog) {
-  return z4.object({
+  return z5.object({
     namespace: eventNamespaceSchema(catalog),
-    identifier: z4.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
+    identifier: z5.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
     resourceType: registeredResourceTypeSchema(catalog),
-    label: z4.string().trim().min(1).max(500),
-    events: z4.array(registeredEventTypeSchema(catalog)).min(1)
+    label: z5.string().trim().min(1).max(500),
+    events: z5.array(registeredEventTypeSchema(catalog)).min(1)
   }).strict();
 }
 function requireSupportedEventTaskTrigger(catalog, trigger) {
@@ -410,22 +502,22 @@ function eventTaskSuccess(task, catalog) {
 
 // src/chat/scheduled-tasks/tasks.ts
 import { and as and3, asc as asc3, desc as desc2, eq as eq2, inArray as inArray2, notInArray, sql as sql3 } from "drizzle-orm";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/chat/scheduled-tasks/types.ts
 import {
-  slackActorSchema as slackActorSchema2,
+  actorUserIdSchema as actorUserIdSchema2,
   slackDestinationSchema as slackDestinationSchema2
 } from "@sentry/junior-plugin-api";
-import { z as z5 } from "zod";
-var scheduledTaskStatusSchema = z5.enum([
+import { z as z6 } from "zod";
+var scheduledTaskStatusSchema = z6.enum([
   "active",
   "blocked",
   "completed",
   "deleted"
 ]);
-var scheduledTaskCredentialModeSchema = z5.enum(["system", "creator"]);
-var scheduledRunStatusSchema = z5.enum([
+var scheduledTaskCredentialModeSchema = z6.enum(["system", "creator"]);
+var scheduledRunStatusSchema = z6.enum([
   "pending",
   "running",
   "completed",
@@ -433,71 +525,71 @@ var scheduledRunStatusSchema = z5.enum([
   "blocked",
   "skipped"
 ]);
-var scheduledTaskPrincipalSchema = z5.object({
-  slackUserId: slackActorSchema2.shape.userId,
-  fullName: z5.string().optional(),
-  userName: z5.string().optional()
+var scheduledTaskPrincipalSchema = z6.object({
+  slackUserId: actorUserIdSchema2,
+  fullName: z6.string().optional(),
+  userName: z6.string().optional()
 }).strict();
-var scheduledTaskRecurrenceSchema = z5.object({
-  dayOfMonth: z5.number().optional(),
-  frequency: z5.enum(["daily", "weekly", "monthly", "yearly"]),
-  interval: z5.number(),
-  month: z5.number().optional(),
-  startDate: z5.string(),
-  time: z5.object({
-    hour: z5.number(),
-    minute: z5.number()
+var scheduledTaskRecurrenceSchema = z6.object({
+  dayOfMonth: z6.number().optional(),
+  frequency: z6.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z6.number(),
+  month: z6.number().optional(),
+  startDate: z6.string(),
+  time: z6.object({
+    hour: z6.number(),
+    minute: z6.number()
   }).strict(),
-  weekdays: z5.array(z5.number()).optional()
+  weekdays: z6.array(z6.number()).optional()
 }).strict();
-var scheduledTaskScheduleSchema = z5.object({
-  description: z5.string(),
-  kind: z5.enum(["one_off", "recurring"]),
+var scheduledTaskScheduleSchema = z6.object({
+  description: z6.string(),
+  kind: z6.enum(["one_off", "recurring"]),
   recurrence: scheduledTaskRecurrenceSchema.optional(),
-  timezone: z5.string()
+  timezone: z6.string()
 }).strict();
-var scheduledTaskExecutionActorSchema = z5.object({
-  platform: z5.literal("system"),
-  name: z5.string()
+var scheduledTaskExecutionActorSchema = z6.object({
+  platform: z6.literal("system"),
+  name: z6.string()
 }).strict();
-var scheduledTaskSchema = z5.object({
-  id: z5.string(),
-  conversationAccess: z5.object({
-    audience: z5.enum(["direct", "group", "channel"]),
-    visibility: z5.enum(["private", "public"])
+var scheduledTaskSchema = z6.object({
+  id: z6.string(),
+  conversationAccess: z6.object({
+    audience: z6.enum(["direct", "group", "channel"]),
+    visibility: z6.enum(["private", "public"])
   }).strict(),
-  createdAtMs: z5.number(),
+  createdAtMs: z6.number(),
   createdBy: scheduledTaskPrincipalSchema,
   /** Authoritative provider identity that created the task. */
-  creatorIdentityId: z5.string(),
+  creatorIdentityId: z6.string(),
   /** Selects system credentials or task-bound creator credential delegation. */
   credentialMode: scheduledTaskCredentialModeSchema,
   destination: slackDestinationSchema2,
   executionActor: scheduledTaskExecutionActorSchema.optional(),
-  lastRunAtMs: z5.number().optional(),
-  nextRunAtMs: z5.number().optional(),
-  originalRequest: z5.string().optional(),
-  runNowAtMs: z5.number().optional(),
+  lastRunAtMs: z6.number().optional(),
+  nextRunAtMs: z6.number().optional(),
+  originalRequest: z6.string().optional(),
+  runNowAtMs: z6.number().optional(),
   schedule: scheduledTaskScheduleSchema,
   status: scheduledTaskStatusSchema,
-  statusReason: z5.string().optional(),
-  task: z5.object({ text: z5.string() }).strict(),
+  statusReason: z6.string().optional(),
+  task: z6.object({ text: z6.string() }).strict(),
   /** SQL-backed short display title generated from the task instruction. */
-  title: z5.string().optional(),
-  updatedAtMs: z5.number()
+  title: z6.string().optional(),
+  updatedAtMs: z6.number()
 }).strict();
-var scheduledRunSchema = z5.object({
-  id: z5.string(),
-  attempt: z5.number(),
-  claimedAtMs: z5.number(),
-  completedAtMs: z5.number().optional(),
-  dispatchId: z5.string().optional(),
-  errorMessage: z5.string().optional(),
-  resultMessageTs: z5.string().optional(),
-  scheduledForMs: z5.number(),
-  startedAtMs: z5.number().optional(),
+var scheduledRunSchema = z6.object({
+  id: z6.string(),
+  attempt: z6.number(),
+  claimedAtMs: z6.number(),
+  completedAtMs: z6.number().optional(),
+  dispatchId: z6.string().optional(),
+  errorMessage: z6.string().optional(),
+  resultMessageTs: z6.string().optional(),
+  scheduledForMs: z6.number(),
+  startedAtMs: z6.number().optional(),
   status: scheduledRunStatusSchema,
-  taskId: z5.string()
+  taskId: z6.string()
 }).strict();
 var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
   platform: "system",
@@ -509,11 +601,11 @@ var SCHEDULER_KEY_PREFIX = "junior:scheduler";
 var retainedScheduledTaskSchema = scheduledTaskSchema.omit({ creatorIdentityId: true, title: true }).extend({
   // TODO(v0.131.0): Remove paused decoding and SQL list filtering after
   // v0.129.x workers can no longer overlap upgrades.
-  status: z6.enum(["active", "blocked", "completed", "deleted", "paused"]),
-  version: z6.number().optional()
+  status: z7.enum(["active", "blocked", "completed", "deleted", "paused"]),
+  version: z7.number().optional()
 }).strict();
 function parseScheduledTaskRow(row) {
-  const record = z6.record(z6.string(), z6.unknown()).safeParse(row.record);
+  const record = z7.record(z7.string(), z7.unknown()).safeParse(row.record);
   if (!record.success) return void 0;
   const {
     creatorIdentityId: legacyCreatorIdentityId,
@@ -523,10 +615,10 @@ function parseScheduledTaskRow(row) {
   const parsed = retainedScheduledTaskSchema.safeParse(retained);
   if (!parsed.success) return void 0;
   const { status, version: _version, ...task } = parsed.data;
-  const fallbackIdentity = row.creatorIdentityId === null ? z6.string().safeParse(legacyCreatorIdentityId) : void 0;
+  const fallbackIdentity = row.creatorIdentityId === null ? z7.string().safeParse(legacyCreatorIdentityId) : void 0;
   const creatorIdentityId = row.creatorIdentityId ?? (fallbackIdentity?.success ? fallbackIdentity.data : void 0);
   if (creatorIdentityId === void 0) return void 0;
-  const fallbackTitle = row.title === null ? z6.string().safeParse(legacyTitle) : void 0;
+  const fallbackTitle = row.title === null ? z7.string().safeParse(legacyTitle) : void 0;
   const titleSource = row.title !== null ? row.title : fallbackTitle?.success ? fallbackTitle.data : void 0;
   const title = titleSource?.trim() || void 0;
   if (status === "paused") {
@@ -539,14 +631,14 @@ function parseScheduledTaskRow(row) {
       ...retained2,
       creatorIdentityId,
       status: "deleted",
-      ...title ? { title } : {}
+      ...title ? { title } : void 0
     };
   }
   return {
     ...task,
     creatorIdentityId,
     status,
-    ...title ? { title } : {}
+    ...title ? { title } : void 0
   };
 }
 function isListedScheduledTask(task) {
@@ -570,7 +662,7 @@ function requireStoredTask(task) {
   }
   const { title, ...current } = parsed.data;
   const normalizedTitle = title?.trim() || void 0;
-  return { ...current, ...normalizedTitle ? { title: normalizedTitle } : {} };
+  return { ...current, ...normalizedTitle ? { title: normalizedTitle } : void 0 };
 }
 function scheduledTaskJsonRecord(task) {
   const { title: _title, ...record } = task;
@@ -968,7 +1060,7 @@ async function storeAttachments(args) {
         conversationId: args.conversationId,
         db: args.db,
         file,
-        ...args.nowMs !== void 0 ? { nowMs: args.nowMs } : {},
+        ...args.nowMs !== void 0 ? { nowMs: args.nowMs } : void 0,
         storage: args.storage
       })
     );
@@ -1040,6 +1132,7 @@ export {
   juniorToolOutputSchema,
   injectContinuationToolName,
   makeStructuredToolOutput,
+  lookupSlackUser,
   eventNamespaceSchema,
   registeredEventTypeSchema,
   registeredResourceTypeSchema,

package/dist/{chunk-FIANEE7Z.js → chunk-CM5HNV2W.js}

@@ -16,9 +16,9 @@ function cloneInlineManifests(registrations) {
               ...plugin.manifest.target,
               configKey: plugin.manifest.target.configKey.includes(".") ? plugin.manifest.target.configKey : `${plugin.manifest.name}.${plugin.manifest.target.configKey}`
             }
-          } : {}
+          } : void 0
         },
-        ...plugin.packageName ? { packageName: plugin.packageName } : {}
+        ...plugin.packageName ? { packageName: plugin.packageName } : void 0
       }
     ] : []
   );
@@ -63,7 +63,7 @@ function defineJuniorPlugins(inputs, options = {}) {
   return {
     packageNames,
     registrations: registrations.map((plugin) => ({ ...plugin })),
-    ...manifests ? { manifests } : {}
+    ...manifests ? { manifests } : void 0
   };
 }
 function pluginCatalogConfigFromPluginSet(pluginSet) {
@@ -84,9 +84,9 @@ function pluginCatalogConfigFromPluginSet(pluginSet) {
     return void 0;
   }
   return {
-    ...inlineManifests ? { inlineManifests } : {},
-    ...packages.length > 0 ? { packages } : {},
-    ...manifests ? { manifests } : {}
+    ...inlineManifests ? { inlineManifests } : void 0,
+    ...packages.length > 0 ? { packages } : void 0,
+    ...manifests ? { manifests } : void 0
   };
 }
 function readEnvPluginPackages(env = process.env) {