@sentry/junior 0.138.0 → 0.139.0

package/dist/{catalog-runtime-IU3QF4GG.js → catalog-runtime-GCCFYPIK.js}

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-QS527AV5.js";
-import "./chunk-KFRHRSCJ.js";
-import "./chunk-77VDLF3Z.js";
+} from "./chunk-6OHTDR4F.js";
+import "./chunk-CXH25EL4.js";
+import "./chunk-RUIXF3YQ.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-JNNJZURV.js";
+import "./chunk-2ECYPYKP.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-KDCHVT25.js";
-import "./chunk-C7ZVPO4Z.js";
+import "./chunk-C2N6MNO4.js";
+import "./chunk-U7CMWQ7Z.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/agent/request.d.ts

@@ -75,10 +75,20 @@ export interface AgentRunInput {
     piMessages?: PiMessage[];
     conversationContext?: string;
 }
-/** Carries identity and addressing needed to route tools, auth, and delivery. */
+/**
+ * Identity and addressing for one run.
+ *
+ * Set `actor` first (who runs). Derive `credentialContext` with
+ * `credentialContextForActor(actor, subject?)` unless a caller already bound
+ * credentials (dispatch with delegated subject). They name the same principal
+ * except when a system actor carries `credentialContext.subject` for delegated
+ * user tokens.
+ */
 export interface AgentRunRouting {
-    credentialContext?: CredentialContext;
+    /** Who this run executes as. Prefer always setting this. */
     actor?: Actor;
+    /** Credential authority projected from actor (plus optional subject). */
+    credentialContext?: CredentialContext;
     source: Source;
     slackConversation?: SlackConversationContext;
     /**

package/dist/chat/credentials/context.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type Actor } from "@/chat/actor";
 declare const credentialSubjectBindingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"slack-direct-conversation">;
     teamId: z.ZodString;
@@ -100,6 +101,19 @@ export type CredentialSubjectBinding = z.output<typeof credentialSubjectBindingS
 export type CredentialSystemActor = z.output<typeof credentialSystemActorSchema>;
 export type CredentialSubject = z.output<typeof credentialSubjectSchema>;
 export type CredentialContext = z.output<typeof credentialContextSchema>;
+/**
+ * Build credential authority from the run actor.
+ *
+ * `actor` is the rich execution principal. This projects the credential stub
+ * tools/auth need from it:
+ * - user actor → `{ actor: { type: "user", userId } }`
+ * - system actor → `{ actor: systemActor, subject? }`
+ *
+ * They only diverge when a system run carries an explicit delegated `subject`
+ * (scheduled/event-task creator credentials). Callers should set `actor` first,
+ * then derive this — do not hand-build parallel shapes.
+ */
+export declare function credentialContextForActor(actor: Actor, subject?: CredentialSubject): CredentialContext;
 /** Return the user whose OAuth token may satisfy this credential request. */
 export declare function credentialUserSubjectId(context: CredentialContext): string | undefined;
 /** Parse an untrusted credential context payload from sandbox egress state. */

package/dist/chat/resource-events/actor.d.ts

@@ -0,0 +1,23 @@
+/** Synthetic Slack author id stamped on resource-event mailbox messages. */
+export declare const RESOURCE_EVENT_SLACK_AUTHOR_ID = "UJRNEVENT";
+/** System execution actor for every resource-event turn. */
+export declare const RESOURCE_EVENT_SYSTEM_ACTOR: {
+    readonly platform: "system";
+    readonly name: "resource-event";
+};
+/** Whether a durable conversation message is a resource-event turn input. */
+export declare function isResourceEventConversationMessage(message: {
+    author?: {
+        userId?: string;
+    };
+    meta?: {
+        eventType?: string;
+    };
+}): boolean;
+/**
+ * Whether a Slack Message payload is a synthetic resource-event notification.
+ * Checks the raw `event_type` marker stamped at mailbox serialization.
+ */
+export declare function isResourceEventSlackMessage(message: {
+    raw?: unknown;
+}): boolean;

package/dist/chat/state/turn-session.d.ts

@@ -42,11 +42,9 @@ export interface AgentTurnSessionRecord {
      * All distinct actors annotated on this run's committed instruction-authority
      * messages, in first-seen order. Persisted as an attribution handle so a
      * summary-only handoff cannot erase them. It never grants authority or
-     * replaces the singular execution actor.
+     * replaces the singular execution actor, which is rebuilt at resume.
      */
     actors: Actor[];
-    /** The single actor this run executes as (credential binding, auth flows). */
-    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;

package/dist/chat/tasks/execution-stats.d.ts

@@ -1,4 +1,6 @@
+import { type TaskExecutionStatus } from "@/db/schema/task-executions";
 export declare const TASK_EXECUTION_TYPES: readonly ["scheduled", "event"];
+export declare const TASK_EXECUTION_STATUSES: readonly ["blocked", "completed", "failed"];
 export type TaskExecutionType = (typeof TASK_EXECUTION_TYPES)[number];
 export type TaskExecutionDay = {
     date: string;
@@ -11,18 +13,47 @@ export type TaskExecutionSummary = {
     runsLast7Days: number;
     totalRuns: number;
 };
-/** Record one successful task execution and its durable conversation. */
+export type TaskExecutionRecord = {
+    conversationId?: string;
+    executedAt: string;
+    executionId: string;
+    status: TaskExecutionStatus;
+    title?: string;
+};
+export type TaskExecutionStatusDay = {
+    blocked: number;
+    completed: number;
+    date: string;
+    failed: number;
+};
+/** Record one terminal task execution and its durable conversation when present. */
 export declare function recordTaskExecution(type: TaskExecutionType, taskId: string, options: {
-    conversationId: string;
+    conversationId?: string;
     executionId: string;
     namespace?: string;
     nowMs?: number;
+    status?: TaskExecutionStatus;
 }): Promise<void>;
 /** Load usage analytics for all tasks of one type and namespace. */
 export declare function readTaskExecutionSummaries(type: TaskExecutionType, namespace: string, options?: {
     nowMs?: number;
 }): Promise<Map<string, TaskExecutionSummary>>;
-/** Load a fixed trailing window of successful executions stacked by task type. */
+/** Load a fixed trailing window of completed executions stacked by task type. */
 export declare function readTaskExecutionDays(dayCount?: number, options?: {
     nowMs?: number;
 }): Promise<TaskExecutionDay[]>;
+/** Load newest-first executions for one task, with conversation titles when present. */
+export declare function readTaskExecutions(args: {
+    kind: TaskExecutionType;
+    limit: number;
+    namespace?: string;
+    taskId: string;
+}): Promise<TaskExecutionRecord[]>;
+/** Load a fixed trailing window of terminal executions for one task by status. */
+export declare function readTaskExecutionStatusDays(args: {
+    dayCount?: number;
+    kind: TaskExecutionType;
+    namespace?: string;
+    nowMs?: number;
+    taskId: string;
+}): Promise<TaskExecutionStatusDay[]>;

package/dist/chat/tasks/read.d.ts

@@ -1,9 +1,11 @@
 import type { User } from "@sentry/junior-plugin-api";
-import type { TaskList } from "@/api/schema/task";
+import type { TaskExecutionList, TaskList } from "@/api/schema/task";
 /** Read viewer-owned and public-workspace tasks as one bounded newest-first projection. */
 export declare function readViewerTasks(user: User): Promise<TaskList>;
 export declare class ViewerTaskNotFoundError extends Error {
     constructor();
 }
+/** Read one viewer-visible task and its newest terminal executions. */
+export declare function readViewerTaskExecutions(user: User, kind: "scheduled" | "event", id: string): Promise<TaskExecutionList>;
 /** Delete one viewer-owned scheduled or event task. */
 export declare function deleteViewerTask(user: User, kind: "scheduled" | "event", id: string): Promise<void>;

package/dist/{chunk-JNNJZURV.js → chunk-2ECYPYKP.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6GWA276C.js";
 import {
   getDeploymentTelemetryAttributes
-} from "./chunk-KDCHVT25.js";
+} from "./chunk-C2N6MNO4.js";
 
 // src/chat/logging.ts
 import path from "path";

package/dist/chunk-3T2JAGRH.js

@@ -0,0 +1,115 @@
+import {
+  healthReportSchema
+} from "./chunk-UTL3MHPC.js";
+import {
+  parseSlackThreadId
+} from "./chunk-MXVD2BDS.js";
+import {
+  normalizeSlackConversationId
+} from "./chunk-6SU2DT27.js";
+
+// src/handlers/health.ts
+function readHealthReport() {
+  return healthReportSchema.parse({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function GET() {
+  return Response.json(readHealthReport());
+}
+
+// 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";
+  return void 0;
+}
+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";
+  }
+  return void 0;
+}
+function toSlackEventChannelType(channelType) {
+  if (channelType === "channel" || channelType === "group" || channelType === "mpim" || channelType === "im") {
+    return channelType;
+  }
+  return void 0;
+}
+function conversationVisibilityFromSlackChannelType(channelType) {
+  if (!channelType) return void 0;
+  return channelType === "channel" ? "public" : "private";
+}
+function resolveSlackChannelTypeFromMessage(message) {
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const channelType = raw.channel_type;
+  return typeof channelType === "string" ? toSlackEventChannelType(channelType.trim()) : void 0;
+}
+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 } : {},
+    ...visibility ? { visibility } : {}
+  };
+}
+function resolveSlackConversationContextFromThreadId(input) {
+  const slackThread = parseSlackThreadId(input.threadId);
+  const context = resolveSlackConversationContext({
+    channelId: slackThread?.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
+  };
+}
+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";
+}
+function formatSlackConversationRedactedLabel(context) {
+  if (!context) return void 0;
+  return formatSlackConversationTypeLabel(context.type);
+}
+
+export {
+  readHealthReport,
+  GET,
+  conversationVisibilityFromSlackChannelType,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  resolveSlackConversationContextFromThreadId,
+  formatSlackConversationRedactedLabel
+};

package/dist/{chunk-PB3CXNVL.js → chunk-4V4QIYJH.js}

@@ -1,6 +1,6 @@
 import {
   createAndEnqueueAgentInvocation
-} from "./chunk-ZBSMCXKV.js";
+} from "./chunk-AEQISMMU.js";
 import {
   actorFromRouting,
   toolInvocationDestination