@sentry/junior 0.146.0 → 0.148.0

package/dist/{chunk-47OSH2ZO.js → chunk-XJ42NBP5.js}

@@ -1,30 +1,34 @@
 import {
   resolveBaseUrl
-} from "./chunk-ZDGHGY74.js";
+} from "./chunk-WCN4YSH7.js";
 import {
   createPluginLogger,
   getPlugins
-} from "./chunk-SCGVWUZX.js";
+} from "./chunk-ZCHIC2GM.js";
+import {
+  getSlackClient,
+  withSlackRetries
+} from "./chunk-V2FXMOEA.js";
 import {
   getDb,
   parseDestination
-} from "./chunk-37EVZP66.js";
+} from "./chunk-VRHTNBA6.js";
 import {
   sleep
 } from "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-GYEKOX7N.js";
+} from "./chunk-2B3PT3V2.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PB222GIA.js";
+} from "./chunk-HWQGBIH7.js";
 import {
   fetchWithBoundedOAuthErrorBodies
-} from "./chunk-37JJDS4H.js";
+} from "./chunk-POSZWRGL.js";
 import {
   isRecord
-} from "./chunk-B63BF443.js";
+} from "./chunk-EAI67NTM.js";
 
 // src/chat/capabilities/router.ts
 var ProviderCredentialRouter = class {
@@ -209,6 +213,379 @@ function getMcpAwareTelemetryMessage(error, _privacy) {
   return getMcpAwareErrorMessage(error);
 }
 
+// src/chat/slack/users.ts
+function normalizeUser(raw) {
+  const rawFields = raw.profile?.fields;
+  const profileFields = [];
+  if (rawFields && typeof rawFields === "object") {
+    for (const [id, field] of Object.entries(rawFields)) {
+      if (!field) continue;
+      profileFields.push({
+        id,
+        label: field.label || void 0,
+        value: field.value || void 0,
+        alt: field.alt || void 0
+      });
+    }
+  }
+  return {
+    id: raw.id ?? "",
+    team_id: raw.team_id || void 0,
+    name: raw.name || void 0,
+    real_name: raw.real_name || raw.profile?.real_name || void 0,
+    display_name: raw.profile?.display_name || void 0,
+    title: raw.profile?.title || void 0,
+    email: raw.profile?.email || void 0,
+    status_text: raw.profile?.status_text ?? void 0,
+    status_emoji: raw.profile?.status_emoji ?? void 0,
+    is_bot: raw.is_bot ?? false,
+    is_deleted: raw.deleted ?? false,
+    timezone: raw.tz || void 0,
+    ...profileFields.length > 0 ? { profile_fields: profileFields } : {}
+  };
+}
+function normalizeNameTokens(value) {
+  return value.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+}
+function nameFields(user) {
+  return [
+    user.name ?? "",
+    user.profile?.display_name ?? "",
+    user.real_name ?? user.profile?.real_name ?? ""
+  ].map((value) => value.toLowerCase().trim()).filter(Boolean);
+}
+async function lookupSlackUserProfile(userId) {
+  const client = getSlackClient();
+  const result = await withSlackRetries(
+    () => client.users.info({ user: userId }),
+    3,
+    { action: "users.info" }
+  );
+  const user = result.user;
+  if (!user) {
+    throw new Error(`Slack users.info returned no user for ${userId}`);
+  }
+  return normalizeUser(user);
+}
+async function lookupSlackUserByEmail(email) {
+  const client = getSlackClient();
+  let result;
+  try {
+    result = await withSlackRetries(
+      () => client.users.lookupByEmail({ email }),
+      3,
+      { action: "users.lookupByEmail" }
+    );
+  } catch (error) {
+    const apiError = error.apiError;
+    if (apiError === "users_not_found") {
+      return null;
+    }
+    throw error;
+  }
+  const user = result.user;
+  if (!user) {
+    return null;
+  }
+  return normalizeUser(user);
+}
+function scoreNameMatch(user, query) {
+  const queryLower = query.toLowerCase().trim();
+  if (!queryLower) return 0;
+  const fields = nameFields(user);
+  if (fields.length === 0) return 0;
+  let best = 0;
+  const queryTokens = normalizeNameTokens(queryLower);
+  for (const field of fields) {
+    if (field === queryLower) {
+      best = Math.max(best, 100);
+      continue;
+    }
+    if (field.startsWith(queryLower)) {
+      best = Math.max(best, 70);
+    } else if (field.includes(queryLower)) {
+      best = Math.max(best, 25);
+    }
+    const tokens = normalizeNameTokens(field);
+    for (const token of tokens) {
+      if (token === queryLower) {
+        best = Math.max(best, 85);
+      } else if (token.startsWith(queryLower)) {
+        best = Math.max(best, 60);
+      }
+    }
+    if (queryTokens.length > 1 && queryTokens.every(
+      (queryToken) => tokens.some(
+        (token) => token === queryToken || token.startsWith(queryToken)
+      )
+    )) {
+      best = Math.max(best, 95);
+    }
+  }
+  return best;
+}
+function compareNameMatches(left, right) {
+  if (right.score !== left.score) return right.score - left.score;
+  return (left.user.name ?? "").localeCompare(right.user.name ?? "");
+}
+async function listWorkspaceUsers(options) {
+  const client = getSlackClient();
+  const matches = [];
+  let cursor;
+  let pages = 0;
+  let totalScanned = 0;
+  while (pages < options.maxPages) {
+    pages++;
+    const result = await withSlackRetries(
+      () => client.users.list({
+        limit: 200,
+        ...cursor ? { cursor } : {}
+      }),
+      3,
+      { action: "users.list" }
+    );
+    const members = result.members ?? [];
+    totalScanned += members.length;
+    for (const member of members) {
+      if (!options.includeDeleted && member.deleted) continue;
+      if (!options.includeBots && member.is_bot) continue;
+      if (member.id === "USLACKBOT") continue;
+      const score = options.score(member);
+      if (score <= 0) continue;
+      matches.push({ user: member, score });
+    }
+    const nextCursor = result.response_metadata?.next_cursor;
+    if (!nextCursor) {
+      cursor = void 0;
+      break;
+    }
+    cursor = nextCursor;
+  }
+  return {
+    matches,
+    searched_pages: pages,
+    searched_user_count: totalScanned,
+    // True only when we hit the page cap with more data remaining.
+    truncated: pages >= options.maxPages && Boolean(cursor)
+  };
+}
+async function searchSlackUsers(options) {
+  const {
+    query,
+    limit = 10,
+    maxPages = 3,
+    includeDeleted = false,
+    includeBots = false
+  } = options;
+  const queryLower = query.toLowerCase().trim();
+  const listed = await listWorkspaceUsers({
+    maxPages,
+    includeDeleted,
+    includeBots,
+    score: (member) => scoreNameMatch(member, queryLower)
+  });
+  listed.matches.sort(compareNameMatches);
+  return {
+    users: listed.matches.slice(0, limit).map((m) => normalizeUser(m.user)),
+    searched_pages: listed.searched_pages,
+    searched_user_count: listed.searched_user_count,
+    truncated: listed.truncated
+  };
+}
+
+// src/chat/plugins/credential-hooks.ts
+import {
+  pluginAuthorizationSchema,
+  pluginCredentialResultSchema,
+  pluginGrantSchema,
+  pluginProviderAccountSchema
+} from "@sentry/junior-plugin-api";
+function parseSchema(schema, value, message) {
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    throw new Error(message);
+  }
+  return result.data;
+}
+function parseAuthorization(value, pluginName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const authorization = parseSchema(
+    pluginAuthorizationSchema,
+    value,
+    `Plugin "${pluginName}" grant authorization is invalid`
+  );
+  if (authorization.provider !== pluginName) {
+    throw new Error(
+      `Plugin "${pluginName}" grant authorization provider must match the issuing plugin`
+    );
+  }
+  return authorization;
+}
+function parseGrant(value, pluginName) {
+  return parseSchema(
+    pluginGrantSchema,
+    value,
+    `Plugin "${pluginName}" grantForEgress returned an invalid grant`
+  );
+}
+function pluginFor(provider) {
+  return getPlugins().find((candidate) => candidate.manifest.name === provider);
+}
+function basePluginContext(plugin) {
+  const pluginName = plugin.manifest.name;
+  return {
+    plugin: { name: pluginName },
+    log: createPluginLogger(pluginName),
+    db: getDb()
+  };
+}
+function parseCredentialResult(value, pluginName) {
+  const result = parseSchema(
+    pluginCredentialResultSchema,
+    value,
+    `Plugin "${pluginName}" issueCredential result is invalid`
+  );
+  if (result.type === "lease") {
+    parseAuthorization(result.lease.authorization, pluginName);
+    return result;
+  }
+  if (result.type === "unavailable") {
+    return result;
+  }
+  parseAuthorization(result.authorization, pluginName);
+  return result;
+}
+async function selectPluginGrant(input) {
+  const plugin = pluginFor(input.provider);
+  const hook = plugin?.hooks?.grantForEgress;
+  if (!plugin || !hook) {
+    return void 0;
+  }
+  const result = await hook({
+    ...basePluginContext(plugin),
+    request: {
+      ...input.bodyText !== void 0 ? { bodyText: input.bodyText } : {},
+      method: input.method,
+      ...input.operation ? { operation: input.operation } : {},
+      url: input.upstreamUrl.toString()
+    }
+  });
+  return result === void 0 ? void 0 : parseGrant(result, plugin.manifest.name);
+}
+async function onPluginEgressResponse(input) {
+  const plugin = pluginFor(input.provider);
+  const hook = plugin?.hooks?.onEgressResponse;
+  if (!plugin || !hook) {
+    return {};
+  }
+  let permissionDenied;
+  await hook({
+    ...basePluginContext(plugin),
+    grant: input.grant,
+    permissionDenied(message) {
+      const trimmed = message.trim();
+      if (!trimmed) {
+        throw new Error(
+          `Plugin "${plugin.manifest.name}" onEgressResponse permissionDenied message is empty`
+        );
+      }
+      permissionDenied = { message: trimmed };
+    },
+    request: {
+      method: input.method,
+      ...input.operation ? { operation: input.operation } : {},
+      url: input.upstreamUrl.toString()
+    },
+    response: input.response
+  });
+  return permissionDenied ? { permissionDenied } : {};
+}
+function hasEgressCredentialHooks(provider) {
+  const hooks = pluginFor(provider)?.hooks;
+  return Boolean(hooks?.grantForEgress || hooks?.issueCredential);
+}
+function getOAuthAccountProviders() {
+  return getPlugins().filter((plugin) => Boolean(plugin.hooks?.resolveOAuthAccount)).map((plugin) => plugin.manifest.name);
+}
+async function resolvePluginOAuthAccount(input) {
+  const plugin = pluginFor(input.provider);
+  const hook = plugin?.hooks?.resolveOAuthAccount;
+  if (!plugin || !hook) {
+    return void 0;
+  }
+  const account = await hook({
+    ...basePluginContext(plugin),
+    tokens: input.tokens
+  });
+  return account === void 0 ? void 0 : parseSchema(
+    pluginProviderAccountSchema,
+    account,
+    `Plugin "${plugin.manifest.name}" resolveOAuthAccount returned an invalid account`
+  );
+}
+async function issuePluginCredential(input) {
+  const plugin = pluginFor(input.provider);
+  const hook = plugin?.hooks?.issueCredential;
+  if (!plugin || !hook) {
+    throw new Error(`Plugin "${input.provider}" has no issueCredential hook`);
+  }
+  const currentUserId = "type" in input.actor ? input.actor.userId : void 0;
+  const credentialSubjectUserId = input.credentialSubject?.userId;
+  const result = await hook({
+    ...basePluginContext(plugin),
+    actor: input.actor,
+    grant: input.grant,
+    ...input.credentialSubject ? { credentialSubject: input.credentialSubject } : {},
+    tokens: {
+      ...currentUserId ? {
+        currentUser: {
+          userId: currentUserId,
+          get: async () => await input.userTokenStore.get(
+            currentUserId,
+            plugin.manifest.name
+          ),
+          set: async (tokens) => {
+            await input.userTokenStore.set(
+              currentUserId,
+              plugin.manifest.name,
+              tokens
+            );
+          },
+          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
+            currentUserId,
+            plugin.manifest.name,
+            callback
+          )
+        }
+      } : {},
+      ...credentialSubjectUserId ? {
+        credentialSubject: {
+          userId: credentialSubjectUserId,
+          get: async () => await input.userTokenStore.get(
+            credentialSubjectUserId,
+            plugin.manifest.name
+          ),
+          set: async (tokens) => {
+            await input.userTokenStore.set(
+              credentialSubjectUserId,
+              plugin.manifest.name,
+              tokens
+            );
+          },
+          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
+            credentialSubjectUserId,
+            plugin.manifest.name,
+            callback
+          )
+        }
+      } : {}
+    }
+  });
+  return parseCredentialResult(result, plugin.manifest.name);
+}
+
 // src/chat/mcp/auth-store.ts
 import {
   sourceSchema
@@ -284,7 +661,6 @@ function parseMcpAuthSession(value) {
       ...typeof parsed.threadTs === "string" ? { threadTs: parsed.threadTs } : {},
       ...typeof parsed.toolChannelId === "string" ? { toolChannelId: parsed.toolChannelId } : {},
       ...isRecord(parsed.configuration) ? { configuration: parsed.configuration } : {},
-      ...isRecord(parsed.artifactState) ? { artifactState: parsed.artifactState } : {},
       ...typeof parsed.authorizationUrl === "string" ? { authorizationUrl: parsed.authorizationUrl } : {},
       ...typeof parsed.codeVerifier === "string" ? { codeVerifier: parsed.codeVerifier } : {}
     };
@@ -683,8 +1059,7 @@ async function createMcpOAuthClientProvider(input) {
       ...input.channelId ? { channelId: input.channelId } : {},
       ...input.threadTs ? { threadTs: input.threadTs } : {},
       ...input.toolChannelId ? { toolChannelId: input.toolChannelId } : {},
-      ...input.configuration ? { configuration: input.configuration } : {},
-      ...input.artifactState ? { artifactState: input.artifactState } : {}
+      ...input.configuration ? { configuration: input.configuration } : {}
     }
   );
 }
@@ -758,196 +1133,6 @@ async function finalizeMcpAuthorization(provider, authSessionId, authorizationCo
   return nextSession;
 }
 
-// src/chat/plugins/credential-hooks.ts
-import {
-  pluginAuthorizationSchema,
-  pluginCredentialResultSchema,
-  pluginGrantSchema,
-  pluginProviderAccountSchema
-} from "@sentry/junior-plugin-api";
-function parseSchema(schema, value, message) {
-  const result = schema.safeParse(value);
-  if (!result.success) {
-    throw new Error(message);
-  }
-  return result.data;
-}
-function parseAuthorization(value, pluginName) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const authorization = parseSchema(
-    pluginAuthorizationSchema,
-    value,
-    `Plugin "${pluginName}" grant authorization is invalid`
-  );
-  if (authorization.provider !== pluginName) {
-    throw new Error(
-      `Plugin "${pluginName}" grant authorization provider must match the issuing plugin`
-    );
-  }
-  return authorization;
-}
-function parseGrant(value, pluginName) {
-  return parseSchema(
-    pluginGrantSchema,
-    value,
-    `Plugin "${pluginName}" grantForEgress returned an invalid grant`
-  );
-}
-function pluginFor(provider) {
-  return getPlugins().find((candidate) => candidate.manifest.name === provider);
-}
-function basePluginContext(plugin) {
-  const pluginName = plugin.manifest.name;
-  return {
-    plugin: { name: pluginName },
-    log: createPluginLogger(pluginName),
-    db: getDb()
-  };
-}
-function parseCredentialResult(value, pluginName) {
-  const result = parseSchema(
-    pluginCredentialResultSchema,
-    value,
-    `Plugin "${pluginName}" issueCredential result is invalid`
-  );
-  if (result.type === "lease") {
-    parseAuthorization(result.lease.authorization, pluginName);
-    return result;
-  }
-  if (result.type === "unavailable") {
-    return result;
-  }
-  parseAuthorization(result.authorization, pluginName);
-  return result;
-}
-async function selectPluginGrant(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.grantForEgress;
-  if (!plugin || !hook) {
-    return void 0;
-  }
-  const result = await hook({
-    ...basePluginContext(plugin),
-    request: {
-      ...input.bodyText !== void 0 ? { bodyText: input.bodyText } : {},
-      method: input.method,
-      ...input.operation ? { operation: input.operation } : {},
-      url: input.upstreamUrl.toString()
-    }
-  });
-  return result === void 0 ? void 0 : parseGrant(result, plugin.manifest.name);
-}
-async function onPluginEgressResponse(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.onEgressResponse;
-  if (!plugin || !hook) {
-    return {};
-  }
-  let permissionDenied;
-  await hook({
-    ...basePluginContext(plugin),
-    grant: input.grant,
-    permissionDenied(message) {
-      const trimmed = message.trim();
-      if (!trimmed) {
-        throw new Error(
-          `Plugin "${plugin.manifest.name}" onEgressResponse permissionDenied message is empty`
-        );
-      }
-      permissionDenied = { message: trimmed };
-    },
-    request: {
-      method: input.method,
-      ...input.operation ? { operation: input.operation } : {},
-      url: input.upstreamUrl.toString()
-    },
-    response: input.response
-  });
-  return permissionDenied ? { permissionDenied } : {};
-}
-function hasEgressCredentialHooks(provider) {
-  const hooks = pluginFor(provider)?.hooks;
-  return Boolean(hooks?.grantForEgress || hooks?.issueCredential);
-}
-async function resolvePluginOAuthAccount(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.resolveOAuthAccount;
-  if (!plugin || !hook) {
-    return void 0;
-  }
-  const account = await hook({
-    ...basePluginContext(plugin),
-    tokens: input.tokens
-  });
-  return account === void 0 ? void 0 : parseSchema(
-    pluginProviderAccountSchema,
-    account,
-    `Plugin "${plugin.manifest.name}" resolveOAuthAccount returned an invalid account`
-  );
-}
-async function issuePluginCredential(input) {
-  const plugin = pluginFor(input.provider);
-  const hook = plugin?.hooks?.issueCredential;
-  if (!plugin || !hook) {
-    throw new Error(`Plugin "${input.provider}" has no issueCredential hook`);
-  }
-  const currentUserId = "type" in input.actor ? input.actor.userId : void 0;
-  const credentialSubjectUserId = input.credentialSubject?.userId;
-  const result = await hook({
-    ...basePluginContext(plugin),
-    actor: input.actor,
-    grant: input.grant,
-    ...input.credentialSubject ? { credentialSubject: input.credentialSubject } : {},
-    tokens: {
-      ...currentUserId ? {
-        currentUser: {
-          userId: currentUserId,
-          get: async () => await input.userTokenStore.get(
-            currentUserId,
-            plugin.manifest.name
-          ),
-          set: async (tokens) => {
-            await input.userTokenStore.set(
-              currentUserId,
-              plugin.manifest.name,
-              tokens
-            );
-          },
-          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
-            currentUserId,
-            plugin.manifest.name,
-            callback
-          )
-        }
-      } : {},
-      ...credentialSubjectUserId ? {
-        credentialSubject: {
-          userId: credentialSubjectUserId,
-          get: async () => await input.userTokenStore.get(
-            credentialSubjectUserId,
-            plugin.manifest.name
-          ),
-          set: async (tokens) => {
-            await input.userTokenStore.set(
-              credentialSubjectUserId,
-              plugin.manifest.name,
-              tokens
-            );
-          },
-          withRefresh: async (callback) => await input.userTokenStore.withRefresh(
-            credentialSubjectUserId,
-            plugin.manifest.name,
-            callback
-          )
-        }
-      } : {}
-    }
-  });
-  return parseCredentialResult(result, plugin.manifest.name);
-}
-
 export {
   createUserTokenStore,
   issueProviderCredentialLease,
@@ -957,6 +1142,15 @@ export {
   McpToolError,
   getMcpAwareErrorType,
   getMcpAwareTelemetryMessage,
+  lookupSlackUserProfile,
+  lookupSlackUserByEmail,
+  searchSlackUsers,
+  selectPluginGrant,
+  onPluginEgressResponse,
+  hasEgressCredentialHooks,
+  getOAuthAccountProviders,
+  resolvePluginOAuthAccount,
+  issuePluginCredential,
   getMcpAuthSession,
   patchMcpAuthSession,
   deleteMcpAuthSession,
@@ -965,10 +1159,5 @@ export {
   deleteMcpStoredOAuthCredentials,
   deleteMcpServerSessionId,
   createMcpOAuthClientProvider,
-  finalizeMcpAuthorization,
-  selectPluginGrant,
-  onPluginEgressResponse,
-  hasEgressCredentialHooks,
-  resolvePluginOAuthAccount,
-  issuePluginCredential
+  finalizeMcpAuthorization
 };