@sentry/junior-scheduler 0.101.0 → 0.102.1

package/src/store.ts

@@ -2,6 +2,7 @@ import {
   pluginCredentialSubjectSchema,
   destinationSchema,
   isSlackDestination,
+  slackActorSchema,
   type PluginReadState,
   type PluginState,
 } from "@sentry/junior-plugin-api";
@@ -22,7 +23,11 @@ import { z } from "zod";
 import { getNextRunAtMs } from "./cadence";
 import * as schedulerSqlSchema from "./db/schema";
 import { juniorSchedulerRuns, juniorSchedulerTasks } from "./db/schema";
-import type { ScheduledRun, ScheduledTask } from "./types";
+import {
+  scheduledTaskCredentialModeSchema,
+  type ScheduledRun,
+  type ScheduledTask,
+} from "./types";
 
 const SCHEDULER_KEY_PREFIX = "junior:scheduler";
 const SCHEDULER_RECORD_TTL_MS = 5 * 365 * 24 * 60 * 60 * 1000;
@@ -39,7 +44,7 @@ export type SchedulerDb = PgDatabase<
 const slackDestinationSchema = destinationSchema.refine(isSlackDestination);
 const taskPrincipalSchema = z
   .object({
-    slackUserId: z.string(),
+    slackUserId: slackActorSchema.shape.userId,
     fullName: z.string().optional(),
     userName: z.string().optional(),
   })
@@ -73,37 +78,47 @@ const taskSpecSchema = z
     text: z.string(),
   })
   .strict();
+const taskRecordFields = {
+  id: z.string(),
+  conversationAccess: z
+    .object({
+      audience: z.enum(["direct", "group", "channel"]),
+      visibility: z.enum(["private", "public", "unknown"]),
+    })
+    .strict()
+    .optional(),
+  createdAtMs: z.number(),
+  createdBy: taskPrincipalSchema,
+  destination: slackDestinationSchema,
+  executionActor: z
+    .object({
+      platform: z.literal("system"),
+      name: z.string(),
+    })
+    .strict()
+    .optional(),
+  lastRunAtMs: z.number().optional(),
+  nextRunAtMs: z.number().optional(),
+  originalRequest: z.string().optional(),
+  runNowAtMs: z.number().optional(),
+  schedule: taskScheduleSchema,
+  status: z.enum(["active", "paused", "blocked", "deleted"]),
+  statusReason: z.string().optional(),
+  task: taskSpecSchema,
+  updatedAtMs: z.number(),
+  version: z.number().optional(),
+};
 const taskRecordSchema = z
   .object({
-    id: z.string(),
-    conversationAccess: z
-      .object({
-        audience: z.enum(["direct", "group", "channel"]),
-        visibility: z.enum(["private", "public", "unknown"]),
-      })
-      .strict()
-      .optional(),
-    createdAtMs: z.number(),
-    createdBy: taskPrincipalSchema,
+    ...taskRecordFields,
+    credentialMode: scheduledTaskCredentialModeSchema,
+  })
+  .strict();
+// TODO(v0.101.0): Remove parsing for scheduler task records without credentialMode.
+const legacyTaskRecordSchema = z
+  .object({
+    ...taskRecordFields,
     credentialSubject: pluginCredentialSubjectSchema.optional(),
-    destination: slackDestinationSchema,
-    executionActor: z
-      .object({
-        platform: z.literal("system"),
-        name: z.string(),
-      })
-      .strict()
-      .optional(),
-    lastRunAtMs: z.number().optional(),
-    nextRunAtMs: z.number().optional(),
-    originalRequest: z.string().optional(),
-    runNowAtMs: z.number().optional(),
-    schedule: taskScheduleSchema,
-    status: z.enum(["active", "paused", "blocked", "deleted"]),
-    statusReason: z.string().optional(),
-    task: taskSpecSchema,
-    updatedAtMs: z.number(),
-    version: z.number().optional(),
   })
   .strict();
 const runRecordSchema = z
@@ -431,6 +446,9 @@ function normalizedText(value: string | undefined): string {
 
 function taskDedupeFingerprint(task: ScheduledTask): string {
   return JSON.stringify({
+    credentialMode: task.credentialMode,
+    credentialUserId:
+      task.credentialMode === "creator" ? task.createdBy.slackUserId : null,
     destination: task.destination,
     schedule: {
       kind: task.schedule.kind,
@@ -475,6 +493,25 @@ function parseStoredTask(value: unknown): ScheduledTask | undefined {
   return parsed.success ? stripLegacyTaskFields(parsed.data) : undefined;
 }
 
+/** Decode pre-credential-mode tasks only for the state-to-SQL migration. */
+function parseLegacyStoredTaskForMigration(
+  value: unknown,
+): ScheduledTask | undefined {
+  const parsed = legacyTaskRecordSchema.safeParse(parseJsonRecord(value));
+  if (!parsed.success) {
+    return undefined;
+  }
+  const {
+    credentialSubject: _credentialSubject,
+    version: _version,
+    ...task
+  } = parsed.data;
+  return {
+    ...task,
+    credentialMode: "system",
+  };
+}
+
 /** Decode retained scheduler run state, skipping invalid legacy records. */
 function parseStoredRun(value: unknown): ScheduledRun | undefined {
   const parsed = runRecordSchema.safeParse(parseJsonRecord(value));
@@ -1674,7 +1711,9 @@ export async function migrateSchedulerStateToSql(args: {
   const migratedTasks: ScheduledTask[] = [];
 
   for (const id of ids) {
-    const task = await getTaskFromState(args.state, id);
+    const rawTask = await args.state.get(taskKey(id));
+    const task =
+      parseStoredTask(rawTask) ?? parseLegacyStoredTaskForMigration(rawTask);
     if (!task) {
       missing += 1;
       continue;

package/src/tool-support.ts

@@ -2,9 +2,7 @@ import { randomUUID } from "node:crypto";
 import {
   PluginToolInputError,
   pluginToolResultSchema,
-  pluginCredentialSubjectSchema,
   sourceSchema,
-  type PluginCredentialSubject,
   type SlackDestination,
   type SlackActor,
   type SlackSource,
@@ -23,7 +21,6 @@ import type {
 } from "./types";
 
 export interface SchedulerToolContext {
-  credentialSubject?: PluginCredentialSubject;
   actor?: SlackActor;
   source?: SlackSource;
   store: SchedulerStore;
@@ -44,7 +41,7 @@ const compactTaskResultSchema = z
     recurrence: z.unknown().nullable(),
     next_run_at: z.string().nullable(),
     conversation_access: z.unknown().nullable(),
-    credential_subject: z.unknown().nullable(),
+    credential_mode: z.enum(["system", "creator"]),
     last_run_at: z.string().nullable(),
     run_now_at: z.string().nullable(),
   })
@@ -132,8 +129,12 @@ export function requireActiveConversation(
 /** Require a concrete Slack actor before creating scheduler ownership state. */
 export function requireActor(
   context: SchedulerToolContext,
+  destination: SlackDestination,
 ): ScheduledTaskPrincipal {
-  if (context.actor?.platform !== "slack") {
+  if (
+    context.actor?.platform !== "slack" ||
+    context.actor.teamId !== destination.teamId
+  ) {
     throwToolInputError("No active Slack actor context is available.");
   }
   const userId = context.actor?.userId?.trim();
@@ -168,31 +169,6 @@ export function getConversationAccess(
   return { audience: "channel", visibility: "unknown" };
 }
 
-/** Carry private-DM credential authority only when scheduled work is allowed to reuse it. */
-export function getCredentialSubject(args: {
-  access: ScheduledTaskConversationAccess;
-  subject: PluginCredentialSubject | undefined;
-}): PluginCredentialSubject | undefined {
-  if (
-    args.access.audience !== "direct" ||
-    args.access.visibility !== "private"
-  ) {
-    return undefined;
-  }
-  if (!args.subject) {
-    return undefined;
-  }
-  const subject = pluginCredentialSubjectSchema.safeParse(args.subject);
-  if (!subject.success) {
-    throwToolInputError("Active Slack credential subject is invalid.");
-  }
-  return {
-    type: subject.data.type,
-    userId: subject.data.userId,
-    allowedWhen: subject.data.allowedWhen,
-  };
-}
-
 /** Keep scheduler management operations bound to the task's original Slack destination. */
 export function sameDestination(
   task: ScheduledTask,
@@ -251,12 +227,7 @@ export function compactTask(task: ScheduledTask): CompactTaskResult {
       ? new Date(task.nextRunAtMs).toISOString()
       : null,
     conversation_access: task.conversationAccess ?? null,
-    credential_subject: task.credentialSubject
-      ? {
-          type: task.credentialSubject.type,
-          allowed_when: task.credentialSubject.allowedWhen,
-        }
-      : null,
+    credential_mode: task.credentialMode,
     last_run_at: task.lastRunAtMs
       ? new Date(task.lastRunAtMs).toISOString()
       : null,

package/src/tools/create-task.ts

@@ -7,7 +7,6 @@ import {
   buildTaskId,
   compactTask,
   getConversationAccess,
-  getCredentialSubject,
   getDefaultScheduleTimezone,
   isValidTimeZone,
   parseNextRunAtMs,
@@ -28,7 +27,7 @@ export function createSlackScheduleCreateTaskTool(
 ) {
   return definePluginTool({
     description:
-      "Create a one-time or recurring Junior task in the active Slack conversation. For one-time reminders or one-time scheduled work, omit recurrence entirely; never choose a default recurrence. Use only when the user explicitly asks Junior to do work later or on a recurring cadence. Do not create scheduled polling tasks to watch provider resources when a subscribable tool result can deliver the requested events. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. When the task, schedule, and destination are clear, create it without asking for confirmation; ask only when one of those is ambiguous.",
+      "Create a one-time or recurring Junior task in the active Slack conversation. For one-time reminders or one-time scheduled work, omit recurrence entirely; never choose a default recurrence. Use only when the user explicitly asks Junior to do work later or on a recurring cadence. Do not create scheduled polling tasks to watch provider resources when a subscribable tool result can deliver the requested events. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. Set credential_mode to creator only when the current user explicitly authorizes future scheduled use of their connected credentials. If connected-credential use is needed but authorization is ambiguous, ask before creating the task. Otherwise omit credential_mode and use system credentials. When the task, schedule, destination, and credential mode are clear, create it without another confirmation.",
     executionMode: "sequential",
     inputSchema: z.object({
       task: z.string().min(1).max(4000),
@@ -60,11 +59,18 @@ export function createSlackScheduleCreateTaskTool(
           "Required when schedule_kind is recurring. Omit when schedule_kind is one_off. Recurring tasks run at most once per day: use daily, weekly, monthly, or yearly only.",
         )
         .optional(),
+      credential_mode: z
+        .enum(["system", "creator"])
+        .nullable()
+        .describe(
+          "Use creator only when the current user explicitly authorizes future scheduled use of their connected credentials. Omit or use system otherwise.",
+        )
+        .optional(),
     }),
     outputSchema: scheduleTaskToolResultSchema,
     execute: async (input) => {
       const destination = requireActiveConversation(context);
-      const actor = requireActor(context);
+      const actor = requireActor(context, destination);
 
       const nowMs = Date.now();
       const timezone = input.timezone ?? getDefaultScheduleTimezone();
@@ -83,10 +89,6 @@ export function createSlackScheduleCreateTaskTool(
         timezone,
       });
       const conversationAccess = getConversationAccess(destination);
-      const credentialSubject = getCredentialSubject({
-        access: conversationAccess,
-        subject: context.credentialSubject,
-      });
 
       const task: ScheduledTask = {
         id: buildTaskId(),
@@ -94,7 +96,7 @@ export function createSlackScheduleCreateTaskTool(
         updatedAtMs: nowMs,
         createdBy: actor,
         conversationAccess,
-        ...(credentialSubject ? { credentialSubject } : {}),
+        credentialMode: input.credential_mode ?? "system",
         destination,
         executionActor: SCHEDULED_TASK_SYSTEM_ACTOR,
         nextRunAtMs,

package/src/tools/update-task.ts

@@ -8,6 +8,7 @@ import {
   isValidTimeZone,
   normalizeStatus,
   parseNextRunAtMs,
+  requireActor,
   scheduleTaskToolResult,
   scheduleTaskToolResultSchema,
   schedulerStore,
@@ -23,7 +24,7 @@ export function createSlackScheduleUpdateTaskTool(
 ) {
   return definePluginTool({
     description:
-      "Edit, pause, resume, or reschedule an existing Junior scheduled task in the active Slack conversation. Use only task IDs returned for this conversation. Do not move scheduled tasks across conversations.",
+      "Edit, pause, resume, reschedule, or change credential use for an existing Junior scheduled task in the active Slack conversation. Use only task IDs returned for this conversation. Do not move scheduled tasks across conversations. Set credential_mode to creator only when the task creator explicitly authorizes future scheduled use of their connected credentials. If creator credential use is requested but authorization is ambiguous, ask before enabling it. If another user changes the executable task text, creator credential use is cleared automatically.",
     executionMode: "sequential",
     inputSchema: z.object({
       task_id: z
@@ -53,6 +54,13 @@ export function createSlackScheduleUpdateTaskTool(
           "Set to active, paused, or blocked to resume, pause, or block the task.",
         )
         .optional(),
+      credential_mode: z
+        .enum(["system", "creator"])
+        .nullable()
+        .describe(
+          "Set creator only when the current actor is the task creator and explicitly authorizes future scheduled credential use. Set system to disable delegation.",
+        )
+        .optional(),
     }),
     outputSchema: scheduleTaskToolResultSchema,
     execute: async (input) => {
@@ -60,6 +68,13 @@ export function createSlackScheduleUpdateTaskTool(
         context,
         taskId: input.task_id,
       });
+      const actor = requireActor(context, lookup.destination);
+      const isCreator = actor.slackUserId === lookup.createdBy.slackUserId;
+      if (input.credential_mode === "creator" && !isCreator) {
+        throwToolInputError(
+          "Only the scheduled task creator can enable creator credential use.",
+        );
+      }
 
       const timezone = input.timezone ?? lookup.schedule.timezone;
       validateRecurringFrequencyLimit(input);
@@ -92,9 +107,17 @@ export function createSlackScheduleUpdateTaskTool(
           })
         : lookup.schedule.recurrence;
       const nextStatus = status ?? lookup.status;
+      // Another actor changing executable text revokes creator delegation.
+      const credentialMode =
+        input.task !== undefined &&
+        input.task !== lookup.task.text &&
+        !isCreator
+          ? "system"
+          : (input.credential_mode ?? lookup.credentialMode);
 
       const next: ScheduledTask = {
         ...lookup,
+        credentialMode,
         updatedAtMs: Date.now(),
         nextRunAtMs,
         runNowAtMs: nextStatus === "active" ? lookup.runNowAtMs : undefined,

package/src/types.ts

@@ -1,10 +1,11 @@
-import type {
-  PluginCredentialSubject,
-  SlackDestination,
-  SystemActor,
-} from "@sentry/junior-plugin-api";
+import type { SlackDestination, SystemActor } from "@sentry/junior-plugin-api";
+import { z } from "zod";
 
 export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
+export const scheduledTaskCredentialModeSchema = z.enum(["system", "creator"]);
+export type ScheduledTaskCredentialMode = z.infer<
+  typeof scheduledTaskCredentialModeSchema
+>;
 
 export type ScheduledRunStatus =
   | "pending"
@@ -69,7 +70,8 @@ export interface ScheduledTask {
   createdAtMs: number;
   createdBy: ScheduledTaskPrincipal;
   conversationAccess?: ScheduledTaskConversationAccess;
-  credentialSubject?: PluginCredentialSubject;
+  /** Selects system credentials or explicitly delegated creator credentials. */
+  credentialMode: ScheduledTaskCredentialMode;
   destination: SlackDestination;
   executionActor?: ScheduledTaskExecutionActor;
   lastRunAtMs?: number;