@sentry/junior 0.202.0 → 0.204.0

package/dist/web-input-3EPfpf55.js

@@ -0,0 +1,494 @@
+import { o as getSlackBotToken } from "./config-nGCW1OTG.js";
+import { f as logWarn } from "./logging-BzAk1S_s.js";
+import { t as canExposeConversationPayload } from "./conversation-privacy-B4voFRSm.js";
+import "./context-B45_WqVX.js";
+import { Et as getDb, Tt as getConversationStore, U as normalizeSlackConversationId } from "./agent-hooks-Bbcp9e33.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { C as juniorConversations, T as juniorUsers, m as juniorConversationParticipants, w as juniorIdentities } from "./executor-DcMSlI5c.js";
+import { Gt as buildDeterministicTurnId, c as parseSlackThreadId, dt as appendAndEnqueueExclusiveInboundMessage, ft as appendAndEnqueueInboundMessage } from "./stats-DTUbAb88.js";
+import { t as healthReportSchema } from "./reporting-schema-DosTN__Q.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { and, eq, exists, gte, inArray, isNotNull, notExists, or } from "drizzle-orm";
+import { createWebSource, localDestinationSchema } from "@sentry/junior-plugin-api";
+import { alias } from "drizzle-orm/pg-core";
+import { del, get, put } from "@vercel/blob";
+//#region src/handlers/health.ts
+/** Build Junior's process health value for HTTP and reporting consumers. */
+function readHealthReport() {
+	return healthReportSchema.parse({
+		status: "ok",
+		service: "junior",
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+/**
+* Returns a minimal JSON health response for runtime health checks.
+*/
+function GET() {
+	return Response.json(readHealthReport());
+}
+//#endregion
+//#region src/chat/attachments/vercel.ts
+/** Store private conversation attachments in 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",
+				useCache: false
+			});
+			return result?.statusCode === 200 ? result.stream : null;
+		},
+		async delete(keys) {
+			if (keys.length === 0) return;
+			await del(keys);
+		}
+	};
+}
+//#endregion
+//#region src/chat/conversations/web-mailbox.ts
+/** Parse web mailbox metadata written before Source and Actor were complete. */
+const legacyWebMailboxMetadataSchema = z.object({
+	authorEmail: z.string().email(),
+	authorFullName: z.string().min(1).optional(),
+	authorUserId: z.string().min(1),
+	authorUserName: z.string().min(1).optional(),
+	kind: z.literal("api_turn"),
+	messageId: z.string().min(1)
+}).strict();
+//#endregion
+//#region src/chat/slack/user.ts
+const 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()
+	})
+});
+const USER_CACHE_TTL_MS = 3e5;
+const 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
+	});
+}
+/** Fetch Slack user profile info with in-memory TTL cache to avoid repeated API calls. */
+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 result = {
+			userName: payload.user.name?.trim() || void 0,
+			fullName: payload.user.profile?.real_name?.trim() || void 0,
+			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;
+	}
+}
+//#endregion
+//#region 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";
+}
+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";
+}
+function toSlackEventChannelType(channelType) {
+	if (channelType === "channel" || channelType === "group" || channelType === "mpim" || channelType === "im") return channelType;
+}
+/**
+* Map Slack's Events API channel_type to a source-confirmed visibility.
+*
+* Slack's event metadata is the only visibility authority; channel IDs never
+* classify visibility.
+*/
+function conversationVisibilityFromSlackChannelType(channelType) {
+	if (!channelType) return void 0;
+	return channelType === "channel" ? "public" : "private";
+}
+/** Resolve Slack's raw event channel type from a Chat SDK message-like object. */
+function resolveSlackChannelTypeFromMessage(message) {
+	const raw = message.raw;
+	if (!raw || typeof raw !== "object") return;
+	const channelType = raw.channel_type;
+	return typeof channelType === "string" ? toSlackEventChannelType(channelType.trim()) : void 0;
+}
+/** Build Slack conversation facts available to runtime consumers. */
+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
+	};
+}
+/** Build Slack conversation facts from Junior's persisted Slack thread id. */
+function resolveSlackConversationContextFromThreadId(input) {
+	const context = resolveSlackConversationContext({
+		channelId: parseSlackThreadId(input.threadId)?.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
+	};
+}
+/** Render a human label for a privacy-preserving Slack conversation type. */
+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";
+}
+/** Render a Slack conversation label without exposing conversation names. */
+function formatSlackConversationRedactedLabel(context) {
+	if (!context) return void 0;
+	return formatSlackConversationTypeLabel(context.type);
+}
+//#endregion
+//#region src/chat/conversations/destination.ts
+function requireLocalDestination(conversationId) {
+	const parsed = localDestinationSchema.safeParse({
+		platform: "local",
+		conversationId
+	});
+	if (!parsed.success) throw new Error(`Invalid local conversation id: ${conversationId}`);
+	return parsed.data;
+}
+/**
+* Keep a stored Destination, or create the temporary local Destination.
+*
+* TODO(dcramer): Delete this module after Conversation and AgentRun use
+* Location, and web and resource-event Turns no longer need a local
+* Destination.
+*/
+function resolveConversationDestination(args) {
+	return args.existing ?? requireLocalDestination(args.conversationId);
+}
+//#endregion
+//#region src/api/conversations/membership.ts
+/** True when the viewer is a materialized participant on this root conversation. */
+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);
+}
+/**
+* True when a verified primary-email user participates on this root
+* conversation. Used only for the actorEmail feed fallback.
+*/
+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);
+}
+/** True when one user's personal feed has archived this root after the cutoff. */
+function conversationArchivedForUser(userId, archivedAfter) {
+	const archive = getDb().select({ rootConversationId: juniorConversationParticipants.rootConversationId }).from(juniorConversationParticipants).where(and(eq(juniorConversationParticipants.rootConversationId, juniorConversations.conversationId), eq(juniorConversationParticipants.userId, userId), isNotNull(juniorConversationParticipants.archivedAt), archivedAfter ? gte(juniorConversationParticipants.archivedAt, archivedAfter) : void 0));
+	return exists(archive);
+}
+/** True when one user's personal feed has not archived this root. */
+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);
+}
+/** True when one primary-email user's feed archived this root after the cutoff. */
+function conversationArchivedForEmail(email, archivedAfter) {
+	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), archivedAfter ? gte(juniorConversationParticipants.archivedAt, archivedAfter) : void 0));
+	return exists(archive);
+}
+/** True when one primary-email user's personal feed has not archived this root. */
+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);
+}
+/** Root-actor ownership or a materialized participant row for the same person. */
+function viewerConversationMembership(args) {
+	if (args.actorMatch && args.participantMatch) return or(args.actorMatch, args.participantMatch);
+	return args.actorMatch ?? args.participantMatch;
+}
+/** Read personal archive timestamps for a bounded set of conversation roots. */
+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()]] : []));
+}
+/** Find which of the supplied roots include the linked viewer as a participant. */
+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));
+}
+//#endregion
+//#region src/api/conversations/access.ts
+const rootConversation = alias(juniorConversations, "access_root_conversation");
+const rootDestination = alias(juniorDestinations, "access_root_destination");
+const rootIdentity = alias(juniorIdentities, "access_root_identity");
+/** Resolve viewer access for a bounded set of persisted conversations. */
+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, eq(rootConversation.conversationId, juniorConversations.rootConversationId)).leftJoin(rootDestination, eq(rootDestination.id, rootConversation.destinationId)).leftJoin(rootIdentity, eq(rootIdentity.id, rootConversation.actorIdentityId)).where(inArray(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 validRootConversationId = row.rootConversationId !== null && row.rootConversationId === row.storedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && (row.parentConversationId !== null || row.storedRootConversationId === row.conversationId) ? 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
+		}];
+	}));
+}
+//#endregion
+//#region src/chat/conversations/web-input.ts
+/** Store web input in a Conversation mailbox. */
+function normalizeEmail(email) {
+	return email.trim().toLowerCase();
+}
+function stableHex(...parts) {
+	return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
+}
+/**
+* Build a durable Conversation id for one web Actor and create key.
+*
+* Retries with the same key must address the same Conversation before the
+* mailbox Message id is derived.
+*/
+function createConversationId(args) {
+	return `local:web:${stableHex(normalizeEmail(args.actorEmail), args.idempotencyKey)}`;
+}
+/**
+* Build the retry-stable id for one web Message.
+*
+* TODO(dcramer): Replace the `api-msg` prefix after deployed request retries
+* no longer need to derive ids written by the old web input code.
+*/
+function webMessageId(args) {
+	return `api-msg:${stableHex(args.conversationId, args.idempotencyKey)}`;
+}
+/** Return the stable Turn id for one mailbox Message. */
+function conversationTurnIdForMessage(messageId) {
+	return buildDeterministicTurnId(messageId);
+}
+/**
+* Store the dashboard participant in the current Conversation actor field.
+*
+* TODO(dcramer): Remove this StoredSlackActor conversion after Conversation
+* actor storage accepts web Actors directly.
+*/
+function storedActorFromWeb(actor) {
+	return {
+		...actor.email ? { email: normalizeEmail(actor.email) } : void 0,
+		...actor.fullName ? { fullName: actor.fullName } : void 0
+	};
+}
+/** Rebuild the web Actor from durable Conversation identity. */
+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
+	};
+}
+/** Build one web mailbox entry. */
+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",
+		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 },
+				kind: "api_turn",
+				messageId: args.messageId
+			}
+		},
+		receivedAtMs: nowMs,
+		source: "web"
+	};
+}
+/** Record web activity and create a Conversation root when needed. */
+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,
+		destination,
+		nowMs: args.nowMs,
+		actor: storedActorFromWeb(args.actor),
+		...isNewRoot ? { source: "web" } : void 0,
+		...source ? { sessionSource: source } : void 0,
+		...isNewRoot ? { visibility } : void 0
+	});
+	return destination;
+}
+/** Create a Conversation from web input and enqueue its first Message. */
+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 result = await (options.exclusive ? appendAndEnqueueExclusiveInboundMessage : appendAndEnqueueInboundMessage)({
+		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
+	};
+}
+//#endregion
+export { createVercelAttachmentStorage as C, legacyWebMailboxMetadataSchema as S, readHealthReport as T, formatSlackConversationRedactedLabel as _, webActorFromEmail as a, resolveSlackConversationContextFromThreadId as b, conversationArchivedForEmail as c, conversationHasParticipantUser as d, conversationNotArchivedForEmail as f, conversationVisibilityFromSlackChannelType as g, resolveConversationDestination as h, recordWebConversationActivity as i, conversationArchivedForUser as l, viewerConversationMembership as m, conversationTurnIdForMessage as n, readConversationAccessFromSql as o, conversationNotArchivedForUser as p, createAndEnqueueConversation as r, conversationArchiveTimes as s, appendAndEnqueueWebMessage as t, conversationHasParticipantEmail as u, resolveSlackChannelTypeFromMessage as v, GET as w, lookupSlackUser as x, resolveSlackConversationContext as y };