@sentry/junior-scheduler 0.74.1 → 0.76.0

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
 /** Create Junior's built-in trusted scheduler plugin. */
-export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").JuniorPluginRegistration;
-/** Register trusted scheduler runtime hooks for scheduled Junior tasks. */
+export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").PluginRegistration;
+/** Register scheduler runtime hooks for scheduled Junior tasks. */
 export declare const schedulerPlugin: typeof createSchedulerPlugin;

package/dist/schedule-tools.d.ts

@@ -1,18 +1,19 @@
-import { type AgentPluginCredentialSubject, type AgentPluginState, type AgentPluginToolDefinition, type SlackDestination, type SlackRequester } from "@sentry/junior-plugin-api";
+import { type PluginCredentialSubject, type PluginToolDefinition, type SlackRequester, type SlackSource } from "@sentry/junior-plugin-api";
+import { type SchedulerStore } from "./store";
 export interface SchedulerToolContext {
-    credentialSubject?: AgentPluginCredentialSubject;
+    credentialSubject?: PluginCredentialSubject;
     requester?: SlackRequester;
-    source?: SlackDestination;
-    state: AgentPluginState;
+    source?: SlackSource;
+    store: SchedulerStore;
     userText?: string;
 }
 /** Create a tool that stores a scheduled task for the active Slack context. */
-export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that lists scheduled tasks for the active Slack conversation. */
-export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that edits a scheduled task in the active Slack conversation. */
-export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that removes a scheduled task from the active Slack conversation. */
-export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that marks an existing scheduled task due immediately. */
-export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): PluginToolDefinition<any>;

package/dist/store.d.ts

@@ -1,5 +1,9 @@
-import { type AgentPluginReadState, type AgentPluginState } from "@sentry/junior-plugin-api";
+import { type PluginReadState, type PluginState } from "@sentry/junior-plugin-api";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import type { PgQueryResultHKT } from "drizzle-orm/pg-core/session";
+import * as schedulerSqlSchema from "./db/schema";
 import type { ScheduledRun, ScheduledTask } from "./types";
+export type SchedulerDb = PgDatabase<PgQueryResultHKT, typeof schedulerSqlSchema>;
 export interface SchedulerStore {
     claimDueRun(args: {
         nowMs: number;
@@ -51,6 +55,20 @@ export interface SchedulerOperationalStore {
     listTasks(): Promise<ScheduledTask[]>;
 }
 /** Create a scheduler store backed by this plugin's durable state namespace. */
-export declare function createSchedulerStore(state: AgentPluginState): SchedulerStore;
+export declare function createSchedulerStore(state: PluginState): SchedulerStore;
 /** Create a read-only scheduler store for operational reporting. */
-export declare function createSchedulerOperationalStore(state: AgentPluginReadState): SchedulerOperationalStore;
+export declare function createSchedulerOperationalStore(state: PluginReadState): SchedulerOperationalStore;
+/** Create a scheduler store backed by the plugin SQL database. */
+export declare function createSchedulerSqlStore(db: SchedulerDb): SchedulerStore;
+/** Create a read-only scheduler operational store backed by SQL. */
+export declare function createSchedulerOperationalSqlStore(db: SchedulerDb): SchedulerOperationalStore;
+/** Copy retained scheduler plugin-state records into the scheduler SQL tables. */
+export declare function migrateSchedulerStateToSql(args: {
+    db: SchedulerDb;
+    state: PluginState;
+}): Promise<{
+    existing: number;
+    migrated: number;
+    missing: number;
+    scanned: number;
+}>;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPluginCredentialSubject, SlackDestination } from "@sentry/junior-plugin-api";
+import type { PluginCredentialSubject, SlackDestination } from "@sentry/junior-plugin-api";
 export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
 export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
 export interface ScheduledTaskPrincipal {
@@ -46,7 +46,7 @@ export interface ScheduledTask {
     createdAtMs: number;
     createdBy: ScheduledTaskPrincipal;
     conversationAccess?: ScheduledTaskConversationAccess;
-    credentialSubject?: AgentPluginCredentialSubject;
+    credentialSubject?: PluginCredentialSubject;
     destination: SlackDestination;
     executionActor?: ScheduledTaskExecutionActor;
     lastRunAtMs?: number;
@@ -58,7 +58,6 @@ export interface ScheduledTask {
     statusReason?: string;
     task: ScheduledTaskSpec;
     updatedAtMs: number;
-    version: number;
 }
 export interface ScheduledRun {
     id: string;
@@ -67,11 +66,9 @@ export interface ScheduledRun {
     completedAtMs?: number;
     dispatchId?: string;
     errorMessage?: string;
-    idempotencyKey: string;
     resultMessageTs?: string;
     scheduledForMs: number;
     startedAtMs?: number;
     status: ScheduledRunStatus;
     taskId: string;
-    taskVersion: number;
 }

package/migrations/0001_scheduler.sql

@@ -0,0 +1,35 @@
+CREATE TABLE IF NOT EXISTS junior_scheduler_tasks (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  next_run_at_ms BIGINT,
+  run_now_at_ms BIGINT,
+  created_at_ms BIGINT NOT NULL,
+  record JSONB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_team_status_idx
+  ON junior_scheduler_tasks (team_id, created_at_ms, id)
+  WHERE status <> 'deleted';
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_run_now_due_idx
+  ON junior_scheduler_tasks (run_now_at_ms, created_at_ms, id)
+  WHERE status = 'active' AND run_now_at_ms IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_next_run_due_idx
+  ON junior_scheduler_tasks (next_run_at_ms, created_at_ms, id)
+  WHERE status = 'active' AND next_run_at_ms IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS junior_scheduler_runs (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  scheduled_for_ms BIGINT NOT NULL,
+  record JSONB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_runs_task_status_idx
+  ON junior_scheduler_runs (task_id, status, scheduled_for_ms);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_runs_status_idx
+  ON junior_scheduler_runs (status, scheduled_for_ms);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-scheduler",
-  "version": "0.74.1",
+  "version": "0.76.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -19,11 +19,14 @@
   },
   "files": [
     "dist",
+    "migrations",
     "src"
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
-    "@sentry/junior-plugin-api": "0.74.1"
+    "drizzle-orm": "^0.45.2",
+    "zod": "^4.4.3",
+    "@sentry/junior-plugin-api": "0.76.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -32,6 +35,7 @@
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "db:generate": "pnpm dlx drizzle-kit@0.31.10 generate --config drizzle.config.ts",
     "typecheck": "tsc --noEmit"
   }
 }

package/src/db/schema.ts

@@ -0,0 +1,53 @@
+import { sql } from "drizzle-orm";
+import { bigint, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+import type { ScheduledRun, ScheduledTask } from "../types";
+
+export const juniorSchedulerTasks = pgTable(
+  "junior_scheduler_tasks",
+  {
+    id: text("id").primaryKey(),
+    teamId: text("team_id").notNull(),
+    status: text("status").notNull(),
+    nextRunAtMs: bigint("next_run_at_ms", { mode: "number" }),
+    runNowAtMs: bigint("run_now_at_ms", { mode: "number" }),
+    createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type<ScheduledTask>().notNull(),
+  },
+  (table) => [
+    index("junior_scheduler_tasks_team_status_idx")
+      .on(table.teamId, table.createdAtMs, table.id)
+      .where(sql`${table.status} <> 'deleted'`),
+    index("junior_scheduler_tasks_run_now_due_idx")
+      .on(table.runNowAtMs, table.createdAtMs, table.id)
+      .where(
+        sql`${table.status} = 'active' AND ${table.runNowAtMs} IS NOT NULL`,
+      ),
+    index("junior_scheduler_tasks_next_run_due_idx")
+      .on(table.nextRunAtMs, table.createdAtMs, table.id)
+      .where(
+        sql`${table.status} = 'active' AND ${table.nextRunAtMs} IS NOT NULL`,
+      ),
+  ],
+);
+
+export const juniorSchedulerRuns = pgTable(
+  "junior_scheduler_runs",
+  {
+    id: text("id").primaryKey(),
+    taskId: text("task_id").notNull(),
+    status: text("status").notNull(),
+    scheduledForMs: bigint("scheduled_for_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type<ScheduledRun>().notNull(),
+  },
+  (table) => [
+    index("junior_scheduler_runs_task_status_idx").on(
+      table.taskId,
+      table.status,
+      table.scheduledForMs,
+    ),
+    index("junior_scheduler_runs_status_idx").on(
+      table.status,
+      table.scheduledForMs,
+    ),
+  ],
+);

package/src/index.ts

@@ -1,5 +1,4 @@
 export { createSchedulerPlugin, schedulerPlugin } from "./plugin";
-export { buildScheduledTaskRunPrompt } from "./prompt";
 export {
   createSlackScheduleCreateTaskTool,
   createSlackScheduleDeleteTaskTool,
@@ -8,7 +7,12 @@ export {
   createSlackScheduleUpdateTaskTool,
   type SchedulerToolContext,
 } from "./schedule-tools";
-export { createSchedulerStore } from "./store";
+export {
+  createSchedulerOperationalSqlStore,
+  createSchedulerSqlStore,
+  migrateSchedulerStateToSql,
+  type SchedulerDb,
+} from "./store";
 export type {
   ScheduledCalendarFrequency,
   ScheduledLocalTime,

package/src/plugin.ts

@@ -1,19 +1,27 @@
 import {
+  createSlackSource,
   defineJuniorPlugin,
   type Dispatch,
-  type AgentPluginToolDefinition,
+  type PluginToolDefinition,
   type PluginOperationalReportContent,
+  type PluginReadState,
+  type PluginState,
   type SlackDestination,
+  type Source,
   type ToolRegistrationHookContext,
 } from "@sentry/junior-plugin-api";
-import { buildScheduledTaskRunPrompt } from "./prompt";
 import {
-  createSchedulerOperationalStore,
-  createSchedulerStore,
+  createSchedulerOperationalSqlStore,
+  createSchedulerSqlStore,
+  migrateSchedulerStateToSql,
+  type SchedulerDb,
   type SchedulerOperationalStore,
   type SchedulerStore,
 } from "./store";
-import { scheduledTaskPrincipalLabel } from "./identity";
+import {
+  sanitizeScheduledTaskPrincipal,
+  scheduledTaskPrincipalLabel,
+} from "./identity";
 import type {
   ScheduledRun,
   ScheduledTask,
@@ -31,6 +39,60 @@ import {
 const SCHEDULER_HEARTBEAT_LIMIT = 10;
 const DASHBOARD_TABLE_LIMIT = 5;
 
+function singleLineMetadataValue(value: string): string {
+  return value
+    .replace(/[\r\n]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function buildScheduledTaskDispatchMetadata(args: {
+  nowMs: number;
+  run: ScheduledRun;
+  task: ScheduledTask;
+}): Record<string, string> {
+  const { run, task } = args;
+  const creator = sanitizeScheduledTaskPrincipal(task.createdBy);
+  if (!task.task.text?.trim()) {
+    throw new Error("Scheduled task text is required");
+  }
+
+  return {
+    creatorSlackUserId: creator.slackUserId,
+    runId: run.id,
+    schedule: singleLineMetadataValue(task.schedule.description),
+    scheduleKind: task.schedule.kind,
+    scheduledFor: new Date(run.scheduledForMs).toISOString(),
+    runningAt: new Date(args.nowMs).toISOString(),
+    taskId: task.id,
+    timezone: task.schedule.timezone,
+    ...(task.schedule.recurrence
+      ? {
+          recurrenceFrequency: task.schedule.recurrence.frequency,
+          recurrenceInterval: String(task.schedule.recurrence.interval),
+          recurrenceStartDate: task.schedule.recurrence.startDate,
+        }
+      : {}),
+  };
+}
+
+function scheduledTaskDispatchSource(task: ScheduledTask): Source {
+  return createSlackSource({
+    teamId: task.destination.teamId,
+    channelId: task.destination.channelId,
+  });
+}
+
+function schedulerStore(ctx: { db: unknown }): SchedulerStore {
+  return createSchedulerSqlStore(ctx.db as SchedulerDb);
+}
+
+function schedulerOperationalStore(ctx: {
+  db: unknown;
+}): SchedulerOperationalStore {
+  return createSchedulerOperationalSqlStore(ctx.db as SchedulerDb);
+}
+
 function shouldSkipRun(
   task: ScheduledTask,
   run: ScheduledRun,
@@ -55,16 +117,9 @@ function createSchedulerToolContext(
 ): SchedulerToolContext {
   return {
     credentialSubject: ctx.slack?.credentialSubject,
-    source:
-      ctx.source.platform === "slack"
-        ? {
-            platform: "slack",
-            teamId: ctx.source.teamId,
-            channelId: ctx.source.channelId,
-          }
-        : undefined,
+    source: ctx.source.platform === "slack" ? ctx.source : undefined,
     requester: ctx.requester?.platform === "slack" ? ctx.requester : undefined,
-    state: ctx.state,
+    store: schedulerStore(ctx),
     userText: ctx.userText,
   };
 }
@@ -73,7 +128,7 @@ async function applyDispatchResult(args: {
   dispatch: Dispatch;
   nowMs: number;
   run: ScheduledRun;
-  store: ReturnType<typeof createSchedulerStore>;
+  store: SchedulerStore;
 }): Promise<boolean> {
   if (args.dispatch.status === "completed") {
     const completed = await args.store.markRunCompleted({
@@ -367,14 +422,14 @@ export function createSchedulerPlugin() {
       displayName: "Scheduler",
       description: "Scheduled Junior task management and heartbeat dispatch",
     },
-    legacyStatePrefixes: ["junior:scheduler"],
+    packageName: "@sentry/junior-scheduler",
     hooks: {
       tools(ctx) {
         if (
           ctx.source.platform !== "slack" ||
           ctx.requester?.platform !== "slack"
         ) {
-          return {} as Record<string, AgentPluginToolDefinition<any>>;
+          return {} as Record<string, PluginToolDefinition<any>>;
         }
         const context = createSchedulerToolContext(ctx);
         return {
@@ -383,10 +438,10 @@ export function createSchedulerPlugin() {
           slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(context),
           slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(context),
           slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(context),
-        } satisfies Record<string, AgentPluginToolDefinition<any>>;
+        } satisfies Record<string, PluginToolDefinition<any>>;
       },
       async heartbeat(ctx) {
-        const store = createSchedulerStore(ctx.state);
+        const store = schedulerStore(ctx);
         let processedCount = 0;
         let dispatchCount = 0;
         for (const run of await store.listIncompleteRuns()) {
@@ -443,9 +498,9 @@ export function createSchedulerPlugin() {
             continue;
           }
 
-          let prompt: string;
+          let dispatchMetadata: Record<string, string>;
           try {
-            prompt = buildScheduledTaskRunPrompt({
+            dispatchMetadata = buildScheduledTaskDispatchMetadata({
               nowMs: ctx.nowMs,
               run,
               task,
@@ -453,8 +508,8 @@ export function createSchedulerPlugin() {
           } catch (error) {
             const errorMessage =
               error instanceof Error
-                ? `Scheduled task prompt could not be built: ${error.message}`
-                : "Scheduled task prompt could not be built.";
+                ? `Scheduled task dispatch metadata could not be built: ${error.message}`
+                : "Scheduled task dispatch metadata could not be built.";
             await blockClaimedRun({
               errorMessage,
               nowMs: ctx.nowMs,
@@ -471,11 +526,9 @@ export function createSchedulerPlugin() {
                 ? { credentialSubject: task.credentialSubject }
                 : {}),
               destination: task.destination,
-              input: prompt,
-              metadata: {
-                runId: run.id,
-                taskId: task.id,
-              },
+              input: task.task.text,
+              metadata: dispatchMetadata,
+              source: scheduledTaskDispatchSource(task),
             });
           } catch (error) {
             const errorMessage =
@@ -504,12 +557,18 @@ export function createSchedulerPlugin() {
       async operationalReport(ctx) {
         return buildSchedulerOperationalReport({
           nowMs: ctx.nowMs,
-          store: createSchedulerOperationalStore(ctx.state),
+          store: schedulerOperationalStore(ctx),
+        });
+      },
+      async migrateStorage(ctx) {
+        return await migrateSchedulerStateToSql({
+          db: ctx.db as SchedulerDb,
+          state: ctx.state,
         });
       },
     },
   });
 }
 
-/** Register trusted scheduler runtime hooks for scheduled Junior tasks. */
+/** Register scheduler runtime hooks for scheduled Junior tasks. */
 export const schedulerPlugin = createSchedulerPlugin;