@sentry/junior 0.221.1 → 0.223.0

package/dist/web-input-BJpWm6go.js

@@ -0,0 +1,899 @@
+import { f as logWarn } from "./logging-DiN3o3nB.js";
+import { s as getSlackBotToken } from "./config-CtoUVs72.js";
+import "./context-Bplcgypl.js";
+import { K as normalizeSlackConversationId, Kt as getConversationStore, qt as getDb } from "./agent-hooks-DZU5nsd1.js";
+import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
+import { D as juniorIdentities, O as juniorUsers, o as juniorSchedulerTasks } from "./executor-AOhG9X1t.js";
+import { t as fallbackShortTitle } from "./short-title-BHd_jUFX.js";
+import { A as eventAutomationTriggerAvailable, F as effectiveTaskOutcomes, G as listDeletedEventAutomationsCreatedBy, H as eventAutomationBelongsToUser, J as listPublicEventAutomationsForTeams, K as listEventAutomationsCreatedBy, V as deleteEventAutomation, W as getEventAutomation, X as getEventCatalog, _ as parseScheduledAutomationRow, c as parseSlackThreadId, ft as appendAndEnqueueExclusiveInboundMessage, m as listPublicScheduledAutomationsForTeams, p as isListedScheduledAutomation, pt as appendAndEnqueueInboundMessage, qt as buildDeterministicTurnId, v as readScheduledAutomation, y as saveScheduledAutomation } from "./stats-pNGp3G5q.js";
+import { p as healthReportSchema, s as sumUtcHoursIntoSixHours } from "./reporting-window-DbUqng0P.js";
+import { a as readAutomationExecutionStatusDays, c as readAutomationExecutions, i as readAutomationExecutionHours, l as readAutomationRuns, n as readAutomationExecutionByConversationId, o as readAutomationExecutionStatusHours, r as readAutomationExecutionDays, s as readAutomationExecutionSummaries, t as emptyAutomationRunWindows } from "./execution-stats-CrXs9vSH.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { and, desc, eq, inArray, lt, notInArray, or, sql } from "drizzle-orm";
+import { createWebSource, localDestinationSchema } from "@sentry/junior-plugin-api";
+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/scheduled-automations/personal.ts
+const cursorSchema = z.object({
+	createdAtMs: z.number().finite(),
+	id: z.string().min(1),
+	query: z.string().max(200).optional(),
+	version: z.literal(1)
+}).strict();
+var InvalidScheduledAutomationCursorError = class extends Error {
+	constructor() {
+		super("Scheduled automation cursor is invalid.");
+		this.name = "InvalidScheduledAutomationCursorError";
+	}
+};
+var PersonalScheduledAutomationNotFoundError = class extends Error {
+	constructor() {
+		super("Scheduled automation was not found.");
+		this.name = "PersonalScheduledAutomationNotFoundError";
+	}
+};
+function normalizeQuery(query) {
+	return query?.trim().toLowerCase() || void 0;
+}
+function decodeCursor(value, query) {
+	if (!value) return void 0;
+	try {
+		const parsed = cursorSchema.parse(JSON.parse(Buffer.from(value, "base64url").toString("utf8")));
+		if (parsed.query !== query) throw new InvalidScheduledAutomationCursorError();
+		return {
+			createdAtMs: parsed.createdAtMs,
+			id: parsed.id
+		};
+	} catch {
+		throw new InvalidScheduledAutomationCursorError();
+	}
+}
+function encodeCursor(task, query) {
+	return Buffer.from(JSON.stringify({
+		createdAtMs: task.createdAtMs,
+		id: task.id,
+		...query ? { query } : void 0,
+		version: 1
+	}), "utf8").toString("base64url");
+}
+/** Delete one scheduled automation created by the viewer. */
+async function deleteViewerScheduledAutomation(db, user, id, nowMs = Date.now()) {
+	const identityIds = new Set(user.identities.map((identity) => identity.id));
+	const task = await readScheduledAutomation(db, id);
+	if (!task || task.status === "deleted" || !identityIds.has(task.creatorIdentityId)) throw new PersonalScheduledAutomationNotFoundError();
+	await saveScheduledAutomation(db, {
+		...task,
+		nextRunAtMs: void 0,
+		runNowAtMs: void 0,
+		status: "deleted",
+		updatedAtMs: nowMs
+	});
+}
+/** List scheduled automations created by the viewer with a stable SQL cursor. */
+async function listViewerScheduledAutomations(db, user, input) {
+	const identityIds = user.identities.map((identity) => identity.id);
+	if (identityIds.length === 0) return { automations: [] };
+	const query = normalizeQuery(input.query);
+	const cursor = decodeCursor(input.cursor, query);
+	const automations = [];
+	let before = cursor;
+	const fetchLimit = input.limit + 1;
+	while (automations.length < fetchLimit) {
+		const cursorFilter = before ? or(lt(juniorSchedulerTasks.createdAtMs, before.createdAtMs), and(eq(juniorSchedulerTasks.createdAtMs, before.createdAtMs), lt(juniorSchedulerTasks.id, before.id))) : void 0;
+		const search = query ? sql`strpos(lower(coalesce(${juniorSchedulerTasks.title}, ${juniorSchedulerTasks.record}->'task'->>'text')), ${query}) > 0` : void 0;
+		const rows = await db.select({
+			createdAtMs: juniorSchedulerTasks.createdAtMs,
+			creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+			id: juniorSchedulerTasks.id,
+			record: juniorSchedulerTasks.record,
+			title: juniorSchedulerTasks.title
+		}).from(juniorSchedulerTasks).where(and(notInArray(juniorSchedulerTasks.status, ["deleted", "paused"]), inArray(juniorSchedulerTasks.creatorIdentityId, identityIds), cursorFilter, search)).orderBy(desc(juniorSchedulerTasks.createdAtMs), desc(juniorSchedulerTasks.id)).limit(fetchLimit);
+		automations.push(...rows.map(parseScheduledAutomationRow).filter(isListedScheduledAutomation));
+		if (rows.length < fetchLimit) break;
+		const last = rows.at(-1);
+		before = {
+			createdAtMs: last.createdAtMs,
+			id: last.id
+		};
+	}
+	const page = automations.slice(0, input.limit);
+	return {
+		automations: page,
+		...automations.length > input.limit && page.length > 0 ? { nextCursor: encodeCursor(page.at(-1), query) } : void 0
+	};
+}
+//#endregion
+//#region src/chat/automations/read.ts
+const TASK_LIST_LIMIT = 100;
+const TASK_FETCH_LIMIT = 101;
+const TASK_EXECUTION_LIST_LIMIT = 100;
+function creatorLabel(creator) {
+	return creator.fullName?.trim() || (creator.userName?.trim() ? `@${creator.userName.trim()}` : "") || creator.slackUserId;
+}
+function creatorKey(teamId, slackUserId) {
+	return `${teamId}:${slackUserId}`;
+}
+async function creatorProfileEmails(candidates) {
+	const selectors = new Map(candidates.map(({ task }) => {
+		const teamId = task.destination.teamId;
+		const slackUserId = task.createdBy.slackUserId;
+		return [creatorKey(teamId, slackUserId), {
+			slackUserId,
+			teamId
+		}];
+	}));
+	if (selectors.size === 0) return /* @__PURE__ */ new Map();
+	const rows = await getDb().select({
+		email: juniorUsers.primaryEmailNormalized,
+		slackUserId: juniorIdentities.providerSubjectId,
+		teamId: juniorIdentities.providerTenantId
+	}).from(juniorIdentities).innerJoin(juniorUsers, eq(juniorUsers.id, juniorIdentities.userId)).where(and(eq(juniorIdentities.kind, "user"), eq(juniorIdentities.provider, "slack"), eq(juniorIdentities.emailVerified, true), or(...[...selectors.values()].map((selector) => and(eq(juniorIdentities.providerTenantId, selector.teamId), eq(juniorIdentities.providerSubjectId, selector.slackUserId))))));
+	return new Map(rows.map((row) => [creatorKey(row.teamId, row.slackUserId), row.email]));
+}
+function destinationKey(destination) {
+	return `${destination.teamId}:${destination.channelId}`;
+}
+function displayText(value, fallback) {
+	return value.trim() || fallback;
+}
+function taskDisplayTitle(title, instruction, fallback) {
+	const stored = title?.trim();
+	if (stored) return stored;
+	return fallbackShortTitle(instruction, fallback);
+}
+async function destinationDetails(destinations) {
+	const selectors = new Map(destinations.map((destination) => [destinationKey(destination), destination]));
+	if (selectors.size === 0) return /* @__PURE__ */ new Map();
+	const rows = await getDb().select({
+		displayName: juniorDestinations.displayName,
+		kind: juniorDestinations.kind,
+		providerDestinationId: juniorDestinations.providerDestinationId,
+		providerTenantId: juniorDestinations.providerTenantId,
+		visibility: juniorDestinations.visibility
+	}).from(juniorDestinations).where(or(...[...selectors.values()].map((destination) => and(eq(juniorDestinations.provider, "slack"), eq(juniorDestinations.providerTenantId, destination.teamId), eq(juniorDestinations.providerDestinationId, destination.channelId)))));
+	return new Map(rows.map((row) => {
+		const name = row.displayName?.trim();
+		const label = name ? row.kind === "channel" ? `#${name.replace(/^#/, "")}` : name : row.kind === "dm" ? "Direct message" : row.kind === "group" ? "Group message" : `Channel ${row.providerDestinationId}`;
+		return [`${row.providerTenantId}:${row.providerDestinationId}`, {
+			label,
+			visibility: row.visibility === "public" ? "public" : "private"
+		}];
+	}));
+}
+function executionSummaryFields(stats) {
+	return {
+		...stats?.lastConversationId ? { lastConversationId: stats.lastConversationId } : void 0,
+		...stats?.lastExecutedAtMs ? { lastRunAt: new Date(stats.lastExecutedAtMs).toISOString() } : void 0,
+		runs: stats?.runs ?? emptyAutomationRunWindows(),
+		totalRuns: stats?.totalRuns ?? 0
+	};
+}
+function scheduledAutomationSummary(task, ownedByViewer, destination, stats, createdByEmail) {
+	if (task.status === "deleted") throw new Error("Deleted scheduled automations cannot enter the Automations view");
+	const nextRunAtMs = task.runNowAtMs ?? task.nextRunAtMs;
+	const instruction = displayText(task.task.text, "Untitled scheduled automation");
+	return {
+		createdAt: new Date(task.createdAtMs).toISOString(),
+		createdBy: creatorLabel(task.createdBy),
+		...createdByEmail ? { createdByEmail } : void 0,
+		destination: {
+			channelId: task.destination.channelId,
+			label: destination.label,
+			teamId: task.destination.teamId,
+			visibility: destination.visibility
+		},
+		id: task.id,
+		instruction,
+		kind: "scheduled",
+		...executionSummaryFields(stats),
+		...nextRunAtMs !== void 0 ? { nextRunAt: new Date(nextRunAtMs).toISOString() } : void 0,
+		ownedByViewer,
+		schedule: displayText(task.schedule.description, "Schedule unavailable"),
+		status: task.status,
+		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
+		title: taskDisplayTitle(task.title, instruction, "Untitled scheduled automation")
+	};
+}
+function eventAutomationSummary(task, ownedByViewer, destination, stats, createdByEmail) {
+	const instruction = task.task.text;
+	return {
+		createdAt: new Date(task.createdAtMs).toISOString(),
+		createdBy: creatorLabel(task.createdBy),
+		...createdByEmail ? { createdByEmail } : void 0,
+		destination: {
+			channelId: task.destination.channelId,
+			label: destination.label,
+			teamId: task.destination.teamId,
+			visibility: destination.visibility
+		},
+		events: task.trigger.events,
+		id: task.id,
+		instruction,
+		kind: "event",
+		...executionSummaryFields(stats),
+		ownedByViewer,
+		resource: `${task.trigger.label} · ${task.trigger.identifier}`,
+		source: task.trigger.namespace,
+		outcomes: effectiveTaskOutcomes(task.outcomes, task.destination),
+		title: taskDisplayTitle(task.title, instruction, "Untitled event automation"),
+		triggerAvailable: eventAutomationTriggerAvailable(task, getEventCatalog())
+	};
+}
+function viewerTeamIds(user) {
+	return [...new Set(user.identities.filter((identity) => identity.provider === "slack").map((identity) => identity.providerTenantId).filter((teamId) => Boolean(teamId)))];
+}
+async function resolveViewerTaskCandidate(user, kind, id) {
+	const db = getDb();
+	const identityIds = new Set(user.identities.map((identity) => identity.id));
+	const teamIds = viewerTeamIds(user);
+	if (kind === "scheduled") {
+		const task = await readScheduledAutomation(db, id);
+		if (!task || task.status === "deleted") return void 0;
+		const ownedByViewer = identityIds.has(task.creatorIdentityId);
+		const destination = (await destinationDetails([task.destination])).get(destinationKey(task.destination));
+		const publicToViewer = teamIds.includes(task.destination.teamId) && destination?.visibility === "public";
+		if (!ownedByViewer && !publicToViewer) return void 0;
+		return {
+			kind: "scheduled",
+			ownedByViewer,
+			publicToViewer,
+			task
+		};
+	}
+	const task = await getEventAutomation(db, id);
+	if (!task || task.status === "deleted") return void 0;
+	const ownedByViewer = eventAutomationBelongsToUser(task, user);
+	const destination = (await destinationDetails([task.destination])).get(destinationKey(task.destination));
+	const publicToViewer = teamIds.includes(task.destination.teamId) && destination?.visibility === "public";
+	if (!ownedByViewer && !publicToViewer) return void 0;
+	return {
+		kind: "event",
+		ownedByViewer,
+		publicToViewer,
+		task
+	};
+}
+/** Read one current Automation summary with the Automations view access rules. */
+async function readViewerAutomationSummary(user, id) {
+	const candidate = await resolveViewerTaskCandidate(user, "scheduled", id) ?? await resolveViewerTaskCandidate(user, "event", id);
+	if (!candidate) return void 0;
+	return automationSummaryForCandidate(candidate);
+}
+async function automationSummaryForCandidate(candidate) {
+	const [destinations, creatorEmails, stats] = await Promise.all([
+		destinationDetails([candidate.task.destination]),
+		creatorProfileEmails([candidate]),
+		readAutomationExecutionSummaries(candidate.kind, "junior")
+	]);
+	const destination = destinations.get(destinationKey(candidate.task.destination)) ?? {
+		label: `Channel ${candidate.task.destination.channelId}`,
+		visibility: "private"
+	};
+	const createdByEmail = creatorEmails.get(creatorKey(candidate.task.destination.teamId, candidate.task.createdBy.slackUserId));
+	if (candidate.kind === "scheduled") return scheduledAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), createdByEmail);
+	return eventAutomationSummary(candidate.task, candidate.ownedByViewer, destination, stats.get(candidate.task.id), createdByEmail);
+}
+/** Read viewer-owned and public-workspace automations as one bounded newest-first projection. */
+function emptyAutomationExecutionDay(date) {
+	return {
+		costUsd: 0,
+		date,
+		event: 0,
+		scheduled: 0
+	};
+}
+function emptyAutomationExecutionStatusDay(date) {
+	return {
+		blocked: 0,
+		completed: 0,
+		date,
+		failed: 0
+	};
+}
+function automationExecutionSixHours(hours, nowMs = Date.now()) {
+	return sumUtcHoursIntoSixHours({
+		empty: emptyAutomationExecutionDay,
+		hours,
+		nowMs
+	});
+}
+function automationExecutionStatusSixHours(hours, nowMs = Date.now()) {
+	return sumUtcHoursIntoSixHours({
+		empty: emptyAutomationExecutionStatusDay,
+		hours,
+		nowMs
+	});
+}
+/** List one viewer's scheduled and event automations, optionally filtered by title or instruction search. */
+async function readViewerAutomations(user, input = {}) {
+	const db = getDb();
+	const query = input.q?.trim().toLowerCase() || void 0;
+	const identityIds = new Set(user.identities.map((identity) => identity.id));
+	const teamIds = viewerTeamIds(user);
+	const [scheduledPage, publicScheduled, eventAutomations, publicEventAutomations] = await Promise.all([
+		listViewerScheduledAutomations(db, user, {
+			limit: TASK_FETCH_LIMIT,
+			query
+		}),
+		listPublicScheduledAutomationsForTeams(db, teamIds, {
+			limit: TASK_FETCH_LIMIT,
+			query
+		}),
+		listEventAutomationsCreatedBy(db, user, TASK_FETCH_LIMIT, query),
+		listPublicEventAutomationsForTeams(db, teamIds, TASK_FETCH_LIMIT, query)
+	]);
+	const candidatesById = /* @__PURE__ */ new Map();
+	const publicScheduledIds = new Set(publicScheduled.map((task) => task.id));
+	const publicEventAutomationIds = new Set(publicEventAutomations.map((task) => task.id));
+	for (const task of [...scheduledPage.automations, ...publicScheduled]) candidatesById.set(`scheduled:${task.id}`, {
+		kind: "scheduled",
+		ownedByViewer: identityIds.has(task.creatorIdentityId),
+		publicToViewer: publicScheduledIds.has(task.id),
+		task
+	});
+	for (const task of [...eventAutomations, ...publicEventAutomations]) candidatesById.set(`event:${task.id}`, {
+		kind: "event",
+		ownedByViewer: eventAutomationBelongsToUser(task, user),
+		publicToViewer: publicEventAutomationIds.has(task.id),
+		task
+	});
+	const candidates = [...candidatesById.values()].sort((left, right) => right.task.createdAtMs - left.task.createdAtMs || right.task.id.localeCompare(left.task.id));
+	const ownedCandidates = candidates.filter((candidate) => candidate.ownedByViewer);
+	const publicCandidates = candidates.filter((candidate) => candidate.publicToViewer);
+	const selectedCandidates = /* @__PURE__ */ new Set([...ownedCandidates.slice(0, TASK_LIST_LIMIT), ...publicCandidates.slice(0, TASK_LIST_LIMIT)]);
+	const selected = candidates.filter((candidate) => selectedCandidates.has(candidate));
+	const [destinations, creatorEmails] = await Promise.all([destinationDetails(selected.map(({ task }) => task.destination)), creatorProfileEmails(selected)]);
+	const visible = selected.filter((candidate) => candidate.ownedByViewer || destinations.get(destinationKey(candidate.task.destination))?.visibility === "public");
+	const [executionDays, executionHours, scheduledStats, eventStats] = await Promise.all([
+		readAutomationExecutionDays(),
+		readAutomationExecutionHours(),
+		readAutomationExecutionSummaries("scheduled", "junior"),
+		readAutomationExecutionSummaries("event", "junior")
+	]);
+	const automations = visible.map((candidate) => {
+		const destination = destinations.get(destinationKey(candidate.task.destination)) ?? {
+			label: `Channel ${candidate.task.destination.channelId}`,
+			visibility: "private"
+		};
+		const createdByEmail = creatorEmails.get(creatorKey(candidate.task.destination.teamId, candidate.task.createdBy.slackUserId));
+		if (candidate.kind === "scheduled") return scheduledAutomationSummary(candidate.task, candidate.ownedByViewer, destination, scheduledStats.get(candidate.task.id), createdByEmail);
+		return eventAutomationSummary(candidate.task, candidate.ownedByViewer, destination, eventStats.get(candidate.task.id), createdByEmail);
+	});
+	return {
+		executionDays,
+		executionHours,
+		executionSixHours: automationExecutionSixHours(executionHours),
+		automations,
+		truncated: ownedCandidates.length > TASK_LIST_LIMIT || publicCandidates.length > TASK_LIST_LIMIT
+	};
+}
+/** Load deleted scheduled automations the viewer still owns, newest first. */
+async function readDeletedOwnedScheduledAutomations(user) {
+	const identityIds = user.identities.map((identity) => identity.id);
+	if (identityIds.length === 0) return [];
+	return (await getDb().select({
+		creatorIdentityId: juniorSchedulerTasks.creatorIdentityId,
+		id: juniorSchedulerTasks.id,
+		record: juniorSchedulerTasks.record,
+		title: juniorSchedulerTasks.title
+	}).from(juniorSchedulerTasks).where(and(eq(juniorSchedulerTasks.status, "deleted"), inArray(juniorSchedulerTasks.creatorIdentityId, identityIds))).orderBy(desc(juniorSchedulerTasks.createdAtMs), desc(juniorSchedulerTasks.id)).limit(TASK_EXECUTION_LIST_LIMIT)).map(parseScheduledAutomationRow).filter((task) => task?.status === "deleted");
+}
+/** Load deleted event automations the viewer still owns, newest first. */
+async function readDeletedOwnedEventAutomations(user) {
+	return await listDeletedEventAutomationsCreatedBy(getDb(), user, TASK_EXECUTION_LIST_LIMIT);
+}
+function automationTitleForRun(run, automationTitles) {
+	return automationTitles.get(`${run.kind}:${run.automationId}`) ?? run.title?.trim() ?? "Untitled task";
+}
+function addDeletedAutomationRun(args, automationTitles, automations) {
+	const key = `${args.kind}:${args.automationId}`;
+	if (automationTitles.has(key)) return;
+	automationTitles.set(key, args.title);
+	automations.push({
+		kind: args.kind,
+		automationId: args.automationId
+	});
+}
+/**
+* Read newest runs across live viewer-visible automations and deleted automations the
+* viewer owns. Deleted task rows stay available so history does not depend on
+* conversation actor membership.
+*/
+async function readViewerAutomationRuns(user) {
+	const [taskList, deletedScheduled, deletedEvent] = await Promise.all([
+		readViewerAutomations(user),
+		readDeletedOwnedScheduledAutomations(user),
+		readDeletedOwnedEventAutomations(user)
+	]);
+	const automationTitles = /* @__PURE__ */ new Map();
+	const automations = [];
+	for (const task of taskList.automations) {
+		automationTitles.set(`${task.kind}:${task.id}`, task.title);
+		automations.push({
+			kind: task.kind,
+			automationId: task.id
+		});
+	}
+	for (const task of deletedScheduled) {
+		const instruction = displayText(task.task.text, "Untitled scheduled automation");
+		addDeletedAutomationRun({
+			kind: "scheduled",
+			automationId: task.id,
+			title: taskDisplayTitle(task.title, instruction, "Untitled scheduled automation")
+		}, automationTitles, automations);
+	}
+	for (const task of deletedEvent) {
+		const instruction = displayText(task.task.text, "Untitled event automation");
+		addDeletedAutomationRun({
+			kind: "event",
+			automationId: task.id,
+			title: taskDisplayTitle(task.title, instruction, "Untitled event automation")
+		}, automationTitles, automations);
+	}
+	const runs = await readAutomationRuns({
+		limit: 101,
+		automations
+	});
+	return {
+		runs: runs.slice(0, TASK_EXECUTION_LIST_LIMIT).map((run) => ({
+			...run,
+			automationTitle: automationTitleForRun(run, automationTitles)
+		})),
+		truncated: runs.length > TASK_EXECUTION_LIST_LIMIT
+	};
+}
+var ViewerTaskNotFoundError = class extends Error {
+	constructor() {
+		super("Task was not found.");
+		this.name = "ViewerTaskNotFoundError";
+	}
+};
+/** Read one viewer-visible task and its newest terminal executions. */
+async function readViewerAutomationExecutions(user, kind, id) {
+	const candidate = await resolveViewerTaskCandidate(user, kind, id);
+	if (!candidate) throw new ViewerTaskNotFoundError();
+	const [automation, executions, executionDays, executionHours] = await Promise.all([
+		automationSummaryForCandidate(candidate),
+		readAutomationExecutions({
+			kind,
+			limit: 101,
+			automationId: id
+		}),
+		readAutomationExecutionStatusDays({
+			kind,
+			automationId: id
+		}),
+		readAutomationExecutionStatusHours({
+			kind,
+			automationId: id
+		})
+	]);
+	return {
+		executionDays,
+		executionHours,
+		executionSixHours: automationExecutionStatusSixHours(executionHours),
+		executions: executions.slice(0, TASK_EXECUTION_LIST_LIMIT),
+		automation,
+		truncated: executions.length > TASK_EXECUTION_LIST_LIMIT
+	};
+}
+/** Resolve the source task for one conversation when a terminal execution links it. */
+async function readConversationSourceTask(args) {
+	const execution = await readAutomationExecutionByConversationId({ conversationId: args.conversationId });
+	if (!execution) return void 0;
+	if (!args.viewer) return { kind: execution.kind };
+	const candidate = await resolveViewerTaskCandidate(args.viewer, execution.kind, execution.automationId);
+	if (!candidate) return { kind: execution.kind };
+	if (candidate.kind === "scheduled") {
+		const instruction = displayText(candidate.task.task.text, "Untitled scheduled automation");
+		return {
+			id: candidate.task.id,
+			kind: "scheduled",
+			label: instruction,
+			title: taskDisplayTitle(candidate.task.title, instruction, "Untitled scheduled automation")
+		};
+	}
+	const instruction = displayText(candidate.task.task.text, "Untitled event automation");
+	return {
+		id: candidate.task.id,
+		kind: "event",
+		label: instruction,
+		title: taskDisplayTitle(candidate.task.title, instruction, "Untitled event automation")
+	};
+}
+/** Delete one viewer-owned scheduled or event automation. */
+async function deleteViewerTask(user, kind, id) {
+	if (kind === "scheduled") try {
+		await deleteViewerScheduledAutomation(getDb(), user, id);
+		return;
+	} catch (error) {
+		if (error instanceof PersonalScheduledAutomationNotFoundError) throw new ViewerTaskNotFoundError();
+		throw error;
+	}
+	const task = await getEventAutomation(getDb(), id);
+	if (!task || task.status === "deleted" || !eventAutomationBelongsToUser(task, user)) throw new ViewerTaskNotFoundError();
+	await deleteEventAutomation(getDb(), id);
+}
+//#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 event Turns no longer need a local
+* Destination.
+*/
+function resolveConversationDestination(args) {
+	return args.existing ?? requireLocalDestination(args.conversationId);
+}
+//#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 { readHealthReport as C, GET as S, readViewerAutomationSummary as _, webActorFromEmail as a, legacyWebMailboxMetadataSchema as b, formatSlackConversationRedactedLabel as c, resolveSlackConversationContextFromThreadId as d, ViewerTaskNotFoundError as f, readViewerAutomationRuns as g, readViewerAutomationExecutions as h, recordWebConversationActivity as i, resolveSlackChannelTypeFromMessage as l, readConversationSourceTask as m, conversationTurnIdForMessage as n, resolveConversationDestination as o, deleteViewerTask as p, createAndEnqueueConversation as r, conversationVisibilityFromSlackChannelType as s, appendAndEnqueueWebMessage as t, resolveSlackConversationContext as u, readViewerAutomations as v, createVercelAttachmentStorage as x, lookupSlackUser as y };