@sentry/junior 0.188.0 → 0.189.0

package/dist/chunk-SR6OMO5C.js

@@ -0,0 +1,703 @@
+import {
+  healthReportSchema
+} from "./chunk-UTL3MHPC.js";
+import {
+  parseSlackThreadId
+} from "./chunk-MVPLEPSI.js";
+import {
+  appendAndEnqueueExclusiveInboundMessage,
+  appendAndEnqueueInboundMessage
+} from "./chunk-WN6VLHOU.js";
+import {
+  buildDeterministicTurnId
+} from "./chunk-DA2KGZZI.js";
+import {
+  normalizeSlackConversationId
+} from "./chunk-MI6ZBDTS.js";
+import {
+  getConversationStore,
+  getDb
+} from "./chunk-CUYFCI4G.js";
+import {
+  juniorConversationParticipants,
+  juniorConversations,
+  juniorIdentities,
+  juniorUsers
+} from "./chunk-5VWAY27R.js";
+import {
+  juniorDestinations
+} from "./chunk-VFUK3X5B.js";
+import {
+  getSlackBotToken
+} from "./chunk-BYBSI5TI.js";
+import {
+  canExposeConversationPayload
+} from "./chunk-DYXVAO2E.js";
+import {
+  logWarn
+} from "./chunk-PY3EIEAF.js";
+
+// src/handlers/health.ts
+function readHealthReport() {
+  return healthReportSchema.parse({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function GET() {
+  return Response.json(readHealthReport());
+}
+
+// src/chat/attachments/vercel.ts
+import { del, get, put } from "@vercel/blob";
+function createVercelAttachmentStorage() {
+  return {
+    provider: "vercel-blob",
+    async put(input) {
+      await put(input.key, input.body, {
+        access: "private",
+        addRandomSuffix: false,
+        allowOverwrite: true,
+        contentType: input.contentType
+      });
+    },
+    async get(key) {
+      const result = await get(key, { access: "private" });
+      return result?.statusCode === 200 ? result.stream : null;
+    },
+    async delete(keys) {
+      if (keys.length === 0) return;
+      await del(keys);
+    }
+  };
+}
+
+// src/api/conversations/access.ts
+import { eq as eq2, inArray as inArray2 } from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
+
+// src/api/conversations/membership.ts
+import {
+  and,
+  eq,
+  exists,
+  inArray,
+  isNotNull,
+  notExists,
+  or
+} from "drizzle-orm";
+function conversationHasParticipantUser(userId) {
+  const participant = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorConversationParticipants.userId, userId)
+    )
+  );
+  return exists(participant);
+}
+function conversationHasParticipantEmail(email) {
+  const participant = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).innerJoin(
+    juniorUsers,
+    eq(juniorUsers.id, juniorConversationParticipants.userId)
+  ).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorUsers.primaryEmailNormalized, email)
+    )
+  );
+  return exists(participant);
+}
+function conversationArchivedForUser(userId) {
+  const archive = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorConversationParticipants.userId, userId),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  );
+  return exists(archive);
+}
+function conversationNotArchivedForUser(userId) {
+  const archive = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorConversationParticipants.userId, userId),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  );
+  return notExists(archive);
+}
+function conversationArchivedForEmail(email) {
+  const archive = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).innerJoin(
+    juniorUsers,
+    eq(juniorUsers.id, juniorConversationParticipants.userId)
+  ).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorUsers.primaryEmailNormalized, email),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  );
+  return exists(archive);
+}
+function conversationNotArchivedForEmail(email) {
+  const archive = getDb().select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).innerJoin(
+    juniorUsers,
+    eq(juniorUsers.id, juniorConversationParticipants.userId)
+  ).where(
+    and(
+      eq(
+        juniorConversationParticipants.rootConversationId,
+        juniorConversations.conversationId
+      ),
+      eq(juniorUsers.primaryEmailNormalized, email),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  );
+  return notExists(archive);
+}
+function viewerConversationMembership(args) {
+  if (args.actorMatch && args.participantMatch) {
+    return or(args.actorMatch, args.participantMatch);
+  }
+  return args.actorMatch ?? args.participantMatch;
+}
+async function conversationArchiveTimes(db, conversationIds, subject) {
+  if (!subject || conversationIds.length === 0) return /* @__PURE__ */ new Map();
+  const query = db.select({
+    archivedAt: juniorConversationParticipants.archivedAt,
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants);
+  const rows = "userId" in subject ? await query.where(
+    and(
+      eq(juniorConversationParticipants.userId, subject.userId),
+      inArray(juniorConversationParticipants.rootConversationId, [
+        ...conversationIds
+      ]),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  ) : await query.innerJoin(
+    juniorUsers,
+    eq(juniorUsers.id, juniorConversationParticipants.userId)
+  ).where(
+    and(
+      eq(juniorUsers.primaryEmailNormalized, subject.email),
+      inArray(juniorConversationParticipants.rootConversationId, [
+        ...conversationIds
+      ]),
+      isNotNull(juniorConversationParticipants.archivedAt)
+    )
+  );
+  return new Map(
+    rows.flatMap(
+      (row) => row.archivedAt ? [[row.rootConversationId, row.archivedAt.getTime()]] : []
+    )
+  );
+}
+async function conversationIdsWithParticipantUser(db, conversationIds, userId) {
+  if (conversationIds.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const rows = await db.select({
+    rootConversationId: juniorConversationParticipants.rootConversationId
+  }).from(juniorConversationParticipants).where(
+    and(
+      eq(juniorConversationParticipants.userId, userId),
+      inArray(juniorConversationParticipants.rootConversationId, [
+        ...conversationIds
+      ])
+    )
+  );
+  return new Set(rows.map((row) => row.rootConversationId));
+}
+
+// src/api/conversations/access.ts
+var rootConversation = alias(juniorConversations, "access_root_conversation");
+var rootDestination = alias(juniorDestinations, "access_root_destination");
+var rootIdentity = alias(juniorIdentities, "access_root_identity");
+async function readConversationAccessFromSql(db, conversationIds, viewer) {
+  if (conversationIds.length === 0) return /* @__PURE__ */ new Map();
+  const normalizedViewerEmail = viewer?.email.trim().toLowerCase() || void 0;
+  const rows = await db.select({
+    conversationId: juniorConversations.conversationId,
+    parentConversationId: juniorConversations.parentConversationId,
+    storedRootConversationId: juniorConversations.rootConversationId,
+    rootConversationId: rootConversation.conversationId,
+    rootParentConversationId: rootConversation.parentConversationId,
+    rootRootConversationId: rootConversation.rootConversationId,
+    visibility: rootDestination.visibility,
+    rootEmailNormalized: rootIdentity.emailNormalized,
+    rootEmailVerified: rootIdentity.emailVerified,
+    rootUserId: rootIdentity.userId
+  }).from(juniorConversations).leftJoin(
+    rootConversation,
+    eq2(
+      rootConversation.conversationId,
+      juniorConversations.rootConversationId
+    )
+  ).leftJoin(
+    rootDestination,
+    eq2(rootDestination.id, rootConversation.destinationId)
+  ).leftJoin(
+    rootIdentity,
+    eq2(rootIdentity.id, rootConversation.actorIdentityId)
+  ).where(inArray2(juniorConversations.conversationId, [...conversationIds]));
+  const membershipConversationIds = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    membershipConversationIds.add(row.conversationId);
+    if (row.storedRootConversationId) {
+      membershipConversationIds.add(row.storedRootConversationId);
+    }
+  }
+  const participantRootIds = viewer !== void 0 ? await conversationIdsWithParticipantUser(
+    db,
+    [...membershipConversationIds],
+    viewer.id
+  ) : /* @__PURE__ */ new Set();
+  return new Map(
+    rows.map((row) => {
+      const hasValidRoot = row.rootConversationId !== null && row.rootConversationId === row.storedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && (row.parentConversationId !== null || row.storedRootConversationId === row.conversationId);
+      const validRootConversationId = hasValidRoot ? row.rootConversationId ?? void 0 : void 0;
+      const visibility = validRootConversationId === void 0 ? null : row.visibility;
+      const isRootActor = validRootConversationId !== void 0 && viewer !== void 0 && (row.rootUserId === viewer.id || normalizedViewerEmail !== void 0 && row.rootEmailVerified === true && row.rootEmailNormalized === normalizedViewerEmail);
+      const isMaterializedParticipant = participantRootIds.has(row.conversationId) || validRootConversationId !== void 0 && participantRootIds.has(validRootConversationId);
+      const isParticipant = isRootActor || isMaterializedParticipant;
+      const canViewPrivateContent = isParticipant || validRootConversationId !== void 0 && canExposeConversationPayload({
+        visibility: visibility ?? void 0
+      });
+      return [
+        row.conversationId,
+        {
+          canViewPrivateContent,
+          isParticipant,
+          visibility
+        }
+      ];
+    })
+  );
+}
+
+// src/chat/conversations/web-input.ts
+import { createHash } from "crypto";
+import { createWebSource } from "@sentry/junior-plugin-api";
+
+// src/chat/conversations/destination.ts
+import {
+  localDestinationSchema
+} from "@sentry/junior-plugin-api";
+function requireLocalDestination(conversationId) {
+  const parsed = localDestinationSchema.safeParse({
+    platform: "local",
+    conversationId
+  });
+  if (!parsed.success) {
+    throw new Error(`Invalid local conversation id: ${conversationId}`);
+  }
+  return parsed.data;
+}
+function resolveConversationDestination(args) {
+  return args.existing ?? requireLocalDestination(args.conversationId);
+}
+
+// src/chat/conversations/web-input.ts
+function normalizeEmail(email) {
+  return email.trim().toLowerCase();
+}
+function stableHex(...parts) {
+  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
+}
+function createConversationId(args) {
+  return `local:web:${stableHex(
+    normalizeEmail(args.actorEmail),
+    args.idempotencyKey
+  )}`;
+}
+function webMessageId(args) {
+  return `api-msg:${stableHex(args.conversationId, args.idempotencyKey)}`;
+}
+function conversationTurnIdForMessage(messageId) {
+  return buildDeterministicTurnId(messageId);
+}
+function storedActorFromWeb(actor) {
+  return {
+    ...actor.email ? { email: normalizeEmail(actor.email) } : void 0,
+    ...actor.fullName ? { fullName: actor.fullName } : void 0
+  };
+}
+function webActorFromEmail(email, profile) {
+  const normalized = normalizeEmail(email);
+  return {
+    platform: "web",
+    userId: `dashboard:${stableHex(normalized)}`,
+    email: normalized,
+    ...profile?.fullName ? { fullName: profile.fullName } : void 0,
+    ...profile?.userName ? { userName: profile.userName } : void 0
+  };
+}
+function buildWebInboundMessage(args) {
+  const text = args.message.trim();
+  if (!text) {
+    throw new Error("Web Message must not be empty");
+  }
+  if (!args.actor.email) {
+    throw new Error("Web Actor requires a verified email");
+  }
+  const destination = resolveConversationDestination({
+    conversationId: args.conversationId,
+    existing: args.destination
+  });
+  const nowMs = args.nowMs ?? Date.now();
+  return {
+    conversationId: args.conversationId,
+    createdAtMs: args.createdAtMs ?? nowMs,
+    delivery: "defer",
+    // TODO(dcramer): Remove InboundMessage.destination after workers read the
+    // Conversation Location and no mailbox reader requires Destination.
+    destination,
+    inboundMessageId: args.messageId,
+    input: {
+      authorId: args.actor.userId,
+      text,
+      metadata: {
+        authorEmail: normalizeEmail(args.actor.email),
+        ...args.actor.fullName && { authorFullName: args.actor.fullName },
+        authorUserId: args.actor.userId,
+        ...args.actor.userName && { authorUserName: args.actor.userName },
+        // TODO(dcramer): Remove api_turn after deployed mailbox readers use
+        // Inbound message Source.kind to identify web input.
+        kind: "api_turn",
+        messageId: args.messageId
+      }
+    },
+    receivedAtMs: nowMs,
+    // TODO(dcramer): Rename this stored field to publish after deployed
+    // mailbox readers and writers use the new name.
+    publishExternally: false,
+    // TODO(dcramer): Replace this string after deployed mailbox readers and
+    // writers use a complete web Source.
+    source: "web"
+  };
+}
+async function recordWebConversationActivity(args) {
+  const store = args.conversationStore ?? getConversationStore();
+  const existing = await store.get({ conversationId: args.conversationId });
+  const destination = resolveConversationDestination({
+    conversationId: args.conversationId,
+    existing: existing?.destination
+  });
+  const isNewRoot = !existing;
+  const visibility = args.rootVisibility === "private" ? "private" : "public";
+  const source = isNewRoot ? createWebSource(args.conversationId, visibility) : void 0;
+  await store.recordActivity({
+    conversationId: args.conversationId,
+    // TODO(dcramer): Remove the Conversation destination write after all
+    // readers use its stored Location.
+    destination,
+    nowMs: args.nowMs,
+    actor: storedActorFromWeb(args.actor),
+    // A dashboard continuation does not replace the root Source.
+    // TODO(dcramer): Remove the Conversation source and sessionSource writes
+    // after every Turn stores Source and all resume readers use that Turn fact.
+    ...isNewRoot ? { source: "web" } : void 0,
+    ...source ? { sessionSource: source } : void 0,
+    ...isNewRoot ? { visibility } : void 0
+  });
+  return destination;
+}
+async function createAndEnqueueConversation(input, options) {
+  if (!input.actor.email) {
+    throw new Error("Web Actor requires a verified email");
+  }
+  const conversationId = createConversationId({
+    actorEmail: input.actor.email,
+    idempotencyKey: input.idempotencyKey
+  });
+  return await appendAndEnqueueWebMessage(
+    {
+      actor: input.actor,
+      conversationId,
+      idempotencyKey: input.idempotencyKey,
+      message: input.message,
+      rootVisibility: input.visibility === "private" ? "private" : "public"
+    },
+    options
+  );
+}
+async function appendAndEnqueueWebMessage(input, options) {
+  const text = input.message.trim();
+  if (!text) {
+    throw new Error("Web Message must not be empty");
+  }
+  if (!input.actor.email) {
+    throw new Error("Web Actor requires a verified email");
+  }
+  const nowMs = options.nowMs ?? Date.now();
+  const messageId = webMessageId({
+    conversationId: input.conversationId,
+    idempotencyKey: input.idempotencyKey
+  });
+  const destination = await recordWebConversationActivity({
+    actor: input.actor,
+    conversationId: input.conversationId,
+    conversationStore: options.conversationStore,
+    nowMs,
+    ...input.rootVisibility && { rootVisibility: input.rootVisibility }
+  });
+  const enqueue = options.exclusive ? appendAndEnqueueExclusiveInboundMessage : appendAndEnqueueInboundMessage;
+  const result = await enqueue({
+    message: buildWebInboundMessage({
+      actor: input.actor,
+      conversationId: input.conversationId,
+      destination,
+      message: text,
+      messageId,
+      nowMs
+    }),
+    conversationStore: options.conversationStore,
+    nowMs,
+    queue: options.queue,
+    state: options.state
+  });
+  const status = result.status === "appended" ? "accepted" : result.status;
+  return {
+    conversationId: input.conversationId,
+    messageId,
+    status
+  };
+}
+
+// src/chat/slack/user.ts
+import { z } from "zod";
+var slackUserInfoSchema = z.object({
+  ok: z.literal(true),
+  user: z.object({
+    name: z.string().nullish(),
+    profile: z.object({
+      email: z.string().nullish(),
+      real_name: z.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/conversations/web-mailbox.ts
+import { z as z2 } from "zod";
+var legacyWebMailboxMetadataSchema = z2.object({
+  authorEmail: z2.string().email(),
+  authorFullName: z2.string().min(1).optional(),
+  authorUserId: z2.string().min(1),
+  authorUserName: z2.string().min(1).optional(),
+  kind: z2.literal("api_turn"),
+  messageId: z2.string().min(1)
+}).strict();
+
+// src/chat/slack/conversation-context.ts
+function normalizeConversationName(type, channelName) {
+  const trimmed = channelName?.trim();
+  if (!trimmed) return void 0;
+  if (type === "public_channel" || type === "private_channel" || type === "private_channel_or_group_dm") {
+    return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+  }
+  return trimmed;
+}
+function typeFromSlackChannelType(channelType) {
+  if (channelType === "channel") return "public_channel";
+  if (channelType === "group") return "private_channel";
+  if (channelType === "mpim") return "group_dm";
+  if (channelType === "im") return "direct_message";
+  return void 0;
+}
+function typeFromChannelId(channelId, channelName) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return void 0;
+  if (normalized.startsWith("C")) return "public_channel";
+  if (normalized.startsWith("D")) return "direct_message";
+  if (normalized.startsWith("G")) {
+    return channelName?.trim().startsWith("mpdm-") ? "group_dm" : "private_channel_or_group_dm";
+  }
+  return void 0;
+}
+function toSlackEventChannelType(channelType) {
+  if (channelType === "channel" || channelType === "group" || channelType === "mpim" || channelType === "im") {
+    return channelType;
+  }
+  return void 0;
+}
+function conversationVisibilityFromSlackChannelType(channelType) {
+  if (!channelType) return void 0;
+  return channelType === "channel" ? "public" : "private";
+}
+function resolveSlackChannelTypeFromMessage(message) {
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const channelType = raw.channel_type;
+  return typeof channelType === "string" ? toSlackEventChannelType(channelType.trim()) : void 0;
+}
+function resolveSlackConversationContext(input) {
+  const type = typeFromSlackChannelType(input.channelType) ?? typeFromChannelId(input.channelId, input.channelName);
+  if (!type) return void 0;
+  const name = normalizeConversationName(type, input.channelName);
+  const visibility = conversationVisibilityFromSlackChannelType(
+    input.channelType
+  );
+  return {
+    type,
+    ...name ? { name } : void 0,
+    ...visibility ? { visibility } : void 0
+  };
+}
+function resolveSlackConversationContextFromThreadId(input) {
+  const slackThread = parseSlackThreadId(input.threadId);
+  const context = resolveSlackConversationContext({
+    channelId: slackThread?.channelId,
+    channelName: input.channelName
+  });
+  if (!context || !input.visibility) {
+    return context;
+  }
+  return {
+    ...context,
+    type: input.visibility === "private" && context.type === "public_channel" ? "private_channel" : context.type,
+    visibility: input.visibility
+  };
+}
+function formatSlackConversationTypeLabel(type) {
+  if (type === "public_channel") return "Public Channel";
+  if (type === "private_channel") return "Private Channel";
+  if (type === "group_dm") return "Group DM";
+  if (type === "direct_message") return "Direct Message";
+  return "Private Channel or Group DM";
+}
+function formatSlackConversationRedactedLabel(context) {
+  if (!context) return void 0;
+  return formatSlackConversationTypeLabel(context.type);
+}
+
+export {
+  readHealthReport,
+  GET,
+  createVercelAttachmentStorage,
+  lookupSlackUser,
+  conversationVisibilityFromSlackChannelType,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  resolveSlackConversationContextFromThreadId,
+  formatSlackConversationRedactedLabel,
+  legacyWebMailboxMetadataSchema,
+  resolveConversationDestination,
+  conversationHasParticipantUser,
+  conversationHasParticipantEmail,
+  conversationArchivedForUser,
+  conversationNotArchivedForUser,
+  conversationArchivedForEmail,
+  conversationNotArchivedForEmail,
+  viewerConversationMembership,
+  conversationArchiveTimes,
+  readConversationAccessFromSql,
+  conversationTurnIdForMessage,
+  webActorFromEmail,
+  recordWebConversationActivity,
+  createAndEnqueueConversation,
+  appendAndEnqueueWebMessage
+};