@sentry/junior 0.128.0 → 0.129.0

package/dist/api.js

@@ -24,13 +24,15 @@ import {
   personalTokenListSchema,
   personalTokenParamsSchema,
   revokePersonalTokenResponseSchema,
-  statsReportSchema
-} from "./chunk-AFJF3RGU.js";
+  statsReportSchema,
+  taskListSchema,
+  taskParamsSchema
+} from "./chunk-BVKP37NE.js";
 import {
   formatSlackConversationRedactedLabel,
   readHealthReport,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-JDCPDJ54.js";
+} from "./chunk-GURSWCI4.js";
 import {
   buildSentryConversationUrl
 } from "./chunk-4CODA7P5.js";
@@ -42,11 +44,20 @@ import {
   skillReportsSchema
 } from "./chunk-UTL3MHPC.js";
 import {
+  createSchedulerSqlStore,
+  deleteEventTask,
+  eventTaskBelongsToUser,
+  eventTaskTriggerAvailable,
+  getEventTask,
+  getResourceEventCatalog,
+  listEventTasksCreatedBy,
+  listPublicEventTasksForTeams,
+  listPublicScheduledTasksForTeams,
   readStats
-} from "./chunk-FJEIX3AH.js";
+} from "./chunk-BDIEEZK7.js";
 import {
   parseSlackThreadId
-} from "./chunk-PBWUUVVG.js";
+} from "./chunk-LV2BQ26V.js";
 import {
   agentTurnUsageSchema,
   hasAgentTurnUsage,
@@ -59,41 +70,41 @@ import {
   listConversationAnnotations,
   renderPluginConversationEvent,
   resolveViewerUser
-} from "./chunk-A76LKS5W.js";
+} from "./chunk-QAOA4GUG.js";
 import {
   decodeStoredConversationEvent,
   getDb,
   getSqlExecutor,
   parseSessionSource
-} from "./chunk-B7FPRGUJ.js";
+} from "./chunk-PQFNTLZI.js";
 import {
   juniorApiTokens,
   juniorConversationEvents,
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-SHMHHXD5.js";
-import "./chunk-G6XQODHM.js";
-import "./chunk-K5ZB3WWH.js";
+} from "./chunk-KB2M27DL.js";
+import "./chunk-3N4MWF3R.js";
+import "./chunk-2BCQKJTX.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
 import {
   canExposeConversationPayload
-} from "./chunk-Z4KTQMWW.js";
+} from "./chunk-GPWHBHAG.js";
 import "./chunk-HZF5P5UN.js";
 import {
   parseSlackChannelId,
   parseSlackTeamId
 } from "./chunk-F3B2YJ76.js";
-import "./chunk-B6E3YA2H.js";
+import "./chunk-P6I7LFKC.js";
 import "./chunk-6GWA276C.js";
-import "./chunk-RYWMDDWK.js";
-import "./chunk-KTGJAWRO.js";
+import "./chunk-K3U5447S.js";
+import "./chunk-NNRV4T2C.js";
 import "./chunk-MLKGABMK.js";
 
 // src/api.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 
 // src/api/conversations/routes.ts
 import { Hono } from "hono";
@@ -2015,7 +2026,7 @@ function readDescriptionText(home) {
   }
 }
 async function readSkillReports() {
-  const { discoverSkills } = await import("./skills-ENIBKF5V.js");
+  const { discoverSkills } = await import("./skills-QIUG4D6M.js");
   const skills = await discoverSkills();
   return skillReportsSchema.parse(
     skills.map((skill) => ({
@@ -2025,7 +2036,7 @@ async function readSkillReports() {
   );
 }
 async function readPlugins() {
-  const { pluginCatalogRuntime } = await import("./catalog-runtime-ZPSA5QM2.js");
+  const { pluginCatalogRuntime } = await import("./catalog-runtime-TN2GPVEI.js");
   return pluginsSchema.parse(
     pluginCatalogRuntime.getProviders().map((plugin) => ({
       configKeys: plugin.manifest.configKeys ?? [],
@@ -2038,7 +2049,7 @@ async function readPlugins() {
 async function readRuntimeInfoReport() {
   const [{ homeDir }, { pluginCatalogRuntime }, plugins, skills] = await Promise.all([
     import("./discovery-GUFTFBTL.js"),
-    import("./catalog-runtime-ZPSA5QM2.js"),
+    import("./catalog-runtime-TN2GPVEI.js"),
     readPlugins(),
     readSkillReports()
   ]);
@@ -2054,7 +2065,7 @@ async function readRuntimeInfoReport() {
 }
 async function readPluginOperationalReportFeed() {
   const nowMs = Date.now();
-  const { getPluginOperationalReports } = await import("./agent-hooks-F75ANGBV.js");
+  const { getPluginOperationalReports } = await import("./agent-hooks-ZM4WMZCN.js");
   return pluginOperationalReportFeedSchema.parse({
     source: "plugins",
     generatedAt: new Date(nowMs).toISOString(),
@@ -3262,8 +3273,8 @@ async function readPluginUserPage(input) {
     (candidate) => candidate.id === input.pageId
   );
   if (!plugin || !page) return void 0;
-  const viewer = await resolveViewerUser(input.email);
-  if (!viewer) {
+  const viewer2 = await resolveViewerUser(input.email);
+  if (!viewer2) {
     throw new Error("Authenticated viewer user could not be resolved");
   }
   const content = pluginUserPageContentSchema.parse(
@@ -3272,7 +3283,7 @@ async function readPluginUserPage(input) {
         db: getDb(),
         log: createPluginLogger(plugin.manifest.name),
         plugin: { name: plugin.manifest.name },
-        viewer
+        viewer: viewer2
       },
       input.query
     )
@@ -3333,6 +3344,396 @@ function createUserPageRoutes() {
   return app;
 }
 
+// src/api/tasks/routes.ts
+import { Hono as Hono6 } from "hono";
+
+// src/chat/tasks/read.ts
+import { and as and14, eq as eq15, or as or3 } from "drizzle-orm";
+
+// src/chat/scheduled-tasks/personal.ts
+import { z as z3 } from "zod";
+var cursorSchema = z3.object({
+  createdAtMs: z3.number().finite(),
+  id: z3.string().min(1),
+  query: z3.string().max(200).optional(),
+  version: z3.literal(1)
+}).strict();
+var InvalidScheduledTaskCursorError = class extends Error {
+  constructor() {
+    super("Scheduled task cursor is invalid.");
+    this.name = "InvalidScheduledTaskCursorError";
+  }
+};
+var PersonalScheduledTaskNotFoundError = class extends Error {
+  constructor() {
+    super("Scheduled task was not found.");
+    this.name = "PersonalScheduledTaskNotFoundError";
+  }
+};
+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 InvalidScheduledTaskCursorError();
+    }
+    return { createdAtMs: parsed.createdAtMs, id: parsed.id };
+  } catch {
+    throw new InvalidScheduledTaskCursorError();
+  }
+}
+function encodeCursor(task, query) {
+  return Buffer.from(
+    JSON.stringify({
+      createdAtMs: task.createdAtMs,
+      id: task.id,
+      ...query ? { query } : {},
+      version: 1
+    }),
+    "utf8"
+  ).toString("base64url");
+}
+function createViewerScheduledTasks(store, user) {
+  const identityIds = new Set(user.identities.map((identity) => identity.id));
+  return {
+    async delete(id, nowMs = Date.now()) {
+      const task = await store.getTask(id);
+      if (!task || task.status === "deleted" || !identityIds.has(task.creatorIdentityId)) {
+        throw new PersonalScheduledTaskNotFoundError();
+      }
+      await store.saveTask({
+        ...task,
+        nextRunAtMs: void 0,
+        runNowAtMs: void 0,
+        status: "deleted",
+        updatedAtMs: nowMs
+      });
+    },
+    async list(input) {
+      const query = normalizeQuery(input.query);
+      const cursor = decodeCursor(input.cursor, query);
+      const matching = await store.listTasksCreatedBy({
+        ...cursor ? { before: cursor } : {},
+        identityIds: [...identityIds],
+        limit: input.limit + 1,
+        ...query ? { query } : {}
+      });
+      const tasks = matching.slice(0, input.limit);
+      return {
+        tasks,
+        ...matching.length > input.limit && tasks.length > 0 ? { nextCursor: encodeCursor(tasks.at(-1), query) } : {}
+      };
+    }
+  };
+}
+
+// src/chat/tasks/read.ts
+var TASK_LIST_LIMIT = 100;
+var TASK_FETCH_LIMIT = TASK_LIST_LIMIT + 1;
+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, eq15(juniorUsers.id, juniorIdentities.userId)).where(
+    and14(
+      eq15(juniorIdentities.kind, "user"),
+      eq15(juniorIdentities.provider, "slack"),
+      eq15(juniorIdentities.emailVerified, true),
+      or3(
+        ...[...selectors.values()].map(
+          (selector) => and14(
+            eq15(juniorIdentities.providerTenantId, selector.teamId),
+            eq15(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;
+}
+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(
+    or3(
+      ...[...selectors.values()].map(
+        (destination) => and14(
+          eq15(juniorDestinations.provider, "slack"),
+          eq15(juniorDestinations.providerTenantId, destination.teamId),
+          eq15(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 scheduledTaskSummary(task, ownedByViewer, destination) {
+  if (task.status === "deleted") {
+    throw new Error("Deleted scheduled tasks cannot enter the Tasks view");
+  }
+  const nextRunAtMs = task.runNowAtMs ?? task.nextRunAtMs;
+  return {
+    createdAt: new Date(task.createdAtMs).toISOString(),
+    createdBy: creatorLabel(task.createdBy),
+    destination: {
+      channelId: task.destination.channelId,
+      label: destination.label,
+      teamId: task.destination.teamId,
+      visibility: destination.visibility
+    },
+    id: task.id,
+    instruction: displayText(task.task.text, "Untitled scheduled task"),
+    kind: "scheduled",
+    ...nextRunAtMs !== void 0 ? { nextRunAt: new Date(nextRunAtMs).toISOString() } : {},
+    ownedByViewer,
+    schedule: displayText(task.schedule.description, "Schedule unavailable"),
+    status: task.status
+  };
+}
+async function readViewerTasks(user) {
+  const db = getDb();
+  const schedulerStore = createSchedulerSqlStore(db);
+  const identityIds = new Set(user.identities.map((identity) => identity.id));
+  const teamIds = [
+    ...new Set(
+      user.identities.filter((identity) => identity.provider === "slack").map((identity) => identity.providerTenantId).filter((teamId) => Boolean(teamId))
+    )
+  ];
+  const [scheduledPage, publicScheduled, eventTasks, publicEventTasks] = await Promise.all([
+    createViewerScheduledTasks(schedulerStore, user).list({
+      limit: TASK_FETCH_LIMIT
+    }),
+    listPublicScheduledTasksForTeams(db, teamIds, TASK_FETCH_LIMIT),
+    listEventTasksCreatedBy(db, user, TASK_FETCH_LIMIT),
+    listPublicEventTasksForTeams(db, teamIds, TASK_FETCH_LIMIT)
+  ]);
+  const candidatesById = /* @__PURE__ */ new Map();
+  const publicScheduledIds = new Set(publicScheduled.map((task) => task.id));
+  const publicEventTaskIds = new Set(publicEventTasks.map((task) => task.id));
+  for (const task of [...scheduledPage.tasks, ...publicScheduled]) {
+    candidatesById.set(`scheduled:${task.id}`, {
+      kind: "scheduled",
+      ownedByViewer: identityIds.has(task.creatorIdentityId),
+      publicToViewer: publicScheduledIds.has(task.id),
+      task
+    });
+  }
+  for (const task of [...eventTasks, ...publicEventTasks]) {
+    candidatesById.set(`event:${task.id}`, {
+      kind: "event",
+      ownedByViewer: eventTaskBelongsToUser(task, user),
+      publicToViewer: publicEventTaskIds.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 eventCatalog = getResourceEventCatalog();
+  const visible = selected.filter(
+    (candidate) => candidate.ownedByViewer || destinations.get(destinationKey(candidate.task.destination))?.visibility === "public"
+  );
+  const tasks = 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") {
+      const summary = scheduledTaskSummary(
+        candidate.task,
+        candidate.ownedByViewer,
+        destination
+      );
+      return {
+        ...summary,
+        ...createdByEmail ? { createdByEmail } : {}
+      };
+    }
+    const task = candidate.task;
+    return {
+      createdAt: new Date(task.createdAtMs).toISOString(),
+      createdBy: creatorLabel(task.createdBy),
+      ...createdByEmail ? { createdByEmail } : {},
+      destination: {
+        channelId: task.destination.channelId,
+        label: destination.label,
+        teamId: task.destination.teamId,
+        visibility: destination.visibility
+      },
+      events: task.trigger.events,
+      id: task.id,
+      instruction: task.task.text,
+      kind: "event",
+      ownedByViewer: candidate.ownedByViewer,
+      resource: `${task.trigger.label} \xB7 ${task.trigger.identifier}`,
+      source: task.trigger.namespace,
+      triggerAvailable: eventTaskTriggerAvailable(task, eventCatalog)
+    };
+  });
+  return {
+    tasks,
+    truncated: ownedCandidates.length > TASK_LIST_LIMIT || publicCandidates.length > TASK_LIST_LIMIT
+  };
+}
+var ViewerTaskNotFoundError = class extends Error {
+  constructor() {
+    super("Task was not found.");
+    this.name = "ViewerTaskNotFoundError";
+  }
+};
+async function deleteViewerTask(user, kind, id) {
+  if (kind === "scheduled") {
+    try {
+      await createViewerScheduledTasks(
+        createSchedulerSqlStore(getDb()),
+        user
+      ).delete(id);
+      return;
+    } catch (error) {
+      if (error instanceof PersonalScheduledTaskNotFoundError) {
+        throw new ViewerTaskNotFoundError();
+      }
+      throw error;
+    }
+  }
+  const task = await getEventTask(getDb(), id);
+  if (!task || !eventTaskBelongsToUser(task, user)) {
+    throw new ViewerTaskNotFoundError();
+  }
+  await deleteEventTask(getDb(), id);
+}
+
+// src/api/tasks/routes.ts
+async function viewer(context) {
+  const email = context.get("verifiedViewerEmail")?.trim();
+  return email ? await resolveViewerUser(email) : void 0;
+}
+function createTaskRoutes() {
+  const app = new Hono6();
+  app.get("/", async (context) => {
+    const user = await viewer(context);
+    return user ? jsonResponse(taskListSchema, await readViewerTasks(user)) : jsonResponse(
+      apiErrorSchema,
+      { error: "Authentication required." },
+      { status: 401 }
+    );
+  });
+  app.delete("/:kind/:id", async (context) => {
+    const user = await viewer(context);
+    if (!user) {
+      return jsonResponse(
+        apiErrorSchema,
+        { error: "Authentication required." },
+        { status: 401 }
+      );
+    }
+    const params = taskParamsSchema.safeParse(context.req.param());
+    if (!params.success) {
+      return jsonResponse(
+        apiErrorSchema,
+        { error: "Invalid task." },
+        { status: 400 }
+      );
+    }
+    try {
+      await deleteViewerTask(user, params.data.kind, params.data.id);
+      return new Response(null, {
+        headers: { "cache-control": "no-store" },
+        status: 204
+      });
+    } catch (error) {
+      if (error instanceof ViewerTaskNotFoundError) {
+        return jsonResponse(
+          apiErrorSchema,
+          { error: error.message },
+          { status: 404 }
+        );
+      }
+      throw error;
+    }
+  });
+  return app;
+}
+
 // src/api/plugins.ts
 var plugins_default = defineApiRoute({
   method: "get",
@@ -3390,13 +3791,14 @@ var routes4 = [
   stats_default2
 ];
 function createJuniorApi() {
-  const app = new Hono6();
+  const app = new Hono7();
   registerApiRoutes(app, routes4);
   app.route("/api/conversations", createConversationRoutes());
   app.route("/api/personal-tokens", createPersonalTokenRoutes());
   app.route("/api/people", createPeopleRoutes());
   app.route("/api/locations", createLocationRoutes());
   app.route("/api/user-pages", createUserPageRoutes());
+  app.route("/api/tasks", createTaskRoutes());
   app.notFound(
     () => jsonResponse(
       apiErrorSchema,

package/dist/app.d.ts

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import { type SandboxResourceConfig } from "@/chat/sandbox/resources";
 import { type JuniorPluginSet } from "./plugins";
 import { type VercelConversationWorkCallbackOptions } from "@/chat/task-execution/vercel-callback";
 import type { WaitUntilFn } from "@/handlers/types";
@@ -22,7 +23,7 @@ export interface JuniorAppOptions {
     /** Direct plugin set override. Usually omitted when `juniorNitro()` uses a plugin module. */
     plugins?: JuniorPluginSet;
     /** Sandbox execution options. */
-    sandbox?: {
+    sandbox?: SandboxResourceConfig & {
         /**
          * Egress domains allowed to carry Sentry trace propagation headers.
          * Entries may be exact domains or leading wildcard domains such as