@sentry/junior 0.56.0 → 0.58.0

package/dist/cli/check.js

@@ -1,9 +1,9 @@
 import {
   parseSkillFile
-} from "../chunk-D3G3YOU4.js";
+} from "../chunk-ITOW4DED.js";
 import {
   parsePluginManifest
-} from "../chunk-TTUY467K.js";
+} from "../chunk-H652GMDH.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-5LUISFEY.js";
 import "../chunk-2KG3PWR4.js";

package/dist/cli/init.js

@@ -118,7 +118,6 @@ async function runInit(dir, log = console.log) {
     },
     dependencies: {
       "@sentry/junior": "latest",
-      "@sentry/node": "^10.0.0",
       hono: "^4.12.0"
     },
     devDependencies: {

package/dist/cli/snapshot-warmup.js

@@ -1,12 +1,14 @@
 import {
-  disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-AA5TIFN5.js";
+} from "../chunk-QDGD5WVN.js";
+import {
+  disconnectStateAdapter
+} from "../chunk-FKEKRBUB.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-TTUY467K.js";
+} from "../chunk-H652GMDH.js";
 import "../chunk-Z3YD6NHK.js";
 import "../chunk-5LUISFEY.js";
 import "../chunk-2KG3PWR4.js";

package/dist/instrumentation.js

@@ -17,6 +17,9 @@ function getBoolean(value, fallback) {
   return fallback;
 }
 function initSentry() {
+  if (sentry_exports.getClient()) {
+    return;
+  }
   const dsn = process.env.SENTRY_DSN;
   const enableLogs = getBoolean(process.env.SENTRY_ENABLE_LOGS, Boolean(dsn));
   sentry_exports.init({

package/dist/reporting.d.ts

@@ -0,0 +1,113 @@
+import type { AgentTurnUsage } from "@/chat/usage";
+import { getPluginPackageContent } from "@/chat/plugins/registry";
+import { type AgentTurnRequester } from "@/chat/state/turn-session";
+export interface HealthReport {
+    status: "ok";
+    service: string;
+    timestamp: string;
+}
+export interface PluginReport {
+    name: string;
+}
+export interface SkillReport {
+    name: string;
+    pluginProvider?: string;
+}
+export interface RuntimeInfoReport {
+    cwd: string;
+    homeDir: string;
+    descriptionText?: string;
+    providers: string[];
+    skills: SkillReport[];
+    packagedContent: ReturnType<typeof getPluginPackageContent>;
+}
+export interface DashboardSessionReport {
+    conversationTitle?: string;
+    cumulativeDurationMs?: number;
+    cumulativeUsage?: AgentTurnUsage;
+    conversationId: string;
+    id: string;
+    status: "active" | "completed" | "failed" | "hung" | "superseded";
+    startedAt: string;
+    lastSeenAt: string;
+    lastProgressAt: string;
+    completedAt?: string;
+    surface?: "slack" | "api" | "scheduler" | "internal";
+    title?: string;
+    requester?: string;
+    requesterIdentity?: AgentTurnRequester;
+    channel?: string;
+    channelName?: string;
+    sentryConversationUrl?: string;
+    sentryTraceUrl?: string;
+    traceId?: string;
+}
+export interface DashboardTranscriptPart {
+    bytes?: number;
+    chars?: number;
+    id?: string;
+    input?: unknown;
+    inputKeys?: string[];
+    inputSizeBytes?: number;
+    inputSizeChars?: number;
+    inputType?: string;
+    name?: string;
+    output?: unknown;
+    outputKeys?: string[];
+    outputSizeBytes?: number;
+    outputSizeChars?: number;
+    outputType?: string;
+    redacted?: boolean;
+    text?: string;
+    type: string;
+}
+export interface DashboardTranscriptMessage {
+    parts: DashboardTranscriptPart[];
+    role: string;
+    timestamp?: number;
+}
+export interface DashboardTurnReport extends DashboardSessionReport {
+    transcriptAvailable: boolean;
+    transcriptMetadata?: DashboardTranscriptMessage[];
+    transcriptMessageCount?: number;
+    transcriptRedacted?: boolean;
+    transcriptRedactionReason?: "non_public_conversation";
+    transcript: DashboardTranscriptMessage[];
+}
+export interface DashboardConversationReport {
+    conversationId: string;
+    generatedAt: string;
+    turns: DashboardTurnReport[];
+}
+export interface DashboardSessionFeed {
+    sessions: DashboardSessionReport[];
+    source: "turn_session_records";
+    generatedAt: string;
+}
+export interface JuniorReporting {
+    /** Read the public runtime health snapshot without exposing discovery data. */
+    getHealth(): Promise<HealthReport>;
+    /** Read authenticated dashboard runtime discovery data. */
+    getRuntimeInfo(): Promise<RuntimeInfoReport>;
+    /** Read configured plugin names for authenticated dashboard views. */
+    getPlugins(): Promise<PluginReport[]>;
+    /** Read discovered skill names for authenticated dashboard views. */
+    getSkills(): Promise<SkillReport[]>;
+    /**
+     * Read recent turn metadata for authenticated dashboard views.
+     *
+     * Keep this API trace-shaped: callers should rely on timestamps, status,
+     * actor, route, usage, and links that can later be reconstructed from spans.
+     */
+    getSessions(): Promise<DashboardSessionFeed>;
+    /**
+     * Read one conversation transcript for the dashboard.
+     *
+     * The current implementation joins turn-session records with expiring session
+     * logs, but the API should stay compatible with a future Sentry trace-history
+     * source. Avoid adding fields that require Redis-only transcript internals.
+     */
+    getConversation(conversationId: string): Promise<DashboardConversationReport>;
+}
+/** Create the read-only reporting boundary used by authenticated dashboard routes. */
+export declare function createJuniorReporting(): JuniorReporting;

package/dist/reporting.js

@@ -0,0 +1,390 @@
+import {
+  GET,
+  buildSentryConversationUrl,
+  buildSentryTraceUrl,
+  getAgentTurnSessionRecord,
+  listAgentTurnSessionSummaries,
+  listAgentTurnSessionSummariesForConversation
+} from "./chunk-I4FDGMFI.js";
+import {
+  discoverSkills
+} from "./chunk-ITOW4DED.js";
+import {
+  canExposeConversationPayload,
+  parseSlackThreadId,
+  resolveConversationPrivacy
+} from "./chunk-FKEKRBUB.js";
+import {
+  getPluginPackageContent,
+  getPluginProviders,
+  isRecord
+} from "./chunk-H652GMDH.js";
+import "./chunk-Z3YD6NHK.js";
+import {
+  homeDir
+} from "./chunk-5LUISFEY.js";
+import "./chunk-2KG3PWR4.js";
+
+// src/reporting.ts
+import { readFileSync } from "fs";
+import path from "path";
+var HUNG_TURN_PROGRESS_MS = 5 * 60 * 1e3;
+var SAFE_METADATA_KEY_LIMIT = 20;
+function readDescriptionText() {
+  try {
+    const raw = readFileSync(
+      path.join(homeDir(), "DESCRIPTION.md"),
+      "utf8"
+    ).trim();
+    return raw || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readHealth() {
+  const res = GET();
+  return await res.json();
+}
+async function readSkills() {
+  const skills = await discoverSkills();
+  return skills.map((skill) => ({
+    name: skill.name,
+    pluginProvider: skill.pluginProvider
+  }));
+}
+async function readPlugins() {
+  return getPluginProviders().map((plugin) => ({
+    name: plugin.manifest.name
+  }));
+}
+function statusFromCheckpoint(summary) {
+  const state = summary.state;
+  if (state === "running" && Date.now() - summary.lastProgressAtMs > HUNG_TURN_PROGRESS_MS) {
+    return "hung";
+  }
+  if (state === "running" || state === "awaiting_resume") {
+    return "active";
+  }
+  if (state === "abandoned") {
+    return "superseded";
+  }
+  return state;
+}
+function surfaceFromConversationId(conversationId) {
+  return parseSlackThreadId(conversationId) ? "slack" : "internal";
+}
+function titleFromSummary(summary) {
+  if (summary.state === "awaiting_resume" && summary.resumeReason) {
+    return `Awaiting ${summary.resumeReason} resume`;
+  }
+  return `Turn ${summary.sessionId}`;
+}
+function requesterLabel(requester) {
+  if (!requester) return void 0;
+  return requester.email ?? requester.slackUserName ?? requester.fullName ?? requester.slackUserId;
+}
+function safePrivateLabel(summary) {
+  const slackThread = parseSlackThreadId(summary.conversationId);
+  if (slackThread?.channelId.startsWith("D")) {
+    return "Direct Message";
+  }
+  if (slackThread?.channelId.startsWith("G")) {
+    return summary.channelName?.startsWith("mpdm-") ? "Group DM" : "Private Channel";
+  }
+  return "Private Channel";
+}
+function sessionReportFromSummary(summary) {
+  const slackThread = parseSlackThreadId(summary.conversationId);
+  const privacy = resolveConversationPrivacy({
+    conversationId: summary.conversationId
+  });
+  const privateLabel = privacy !== "public" ? safePrivateLabel(summary) : void 0;
+  const conversationTitle = privateLabel ?? summary.conversationTitle;
+  const channelName = privateLabel ?? summary.channelName;
+  const requester = requesterLabel(summary.requester);
+  const sentryConversationUrl = buildSentryConversationUrl(
+    summary.conversationId
+  );
+  const sentryTraceUrl = summary.traceId ? buildSentryTraceUrl(summary.traceId) : void 0;
+  return {
+    conversationId: summary.conversationId,
+    ...conversationTitle ? { conversationTitle } : {},
+    id: summary.sessionId,
+    status: statusFromCheckpoint(summary),
+    startedAt: new Date(summary.startedAtMs).toISOString(),
+    lastProgressAt: new Date(summary.lastProgressAtMs).toISOString(),
+    lastSeenAt: new Date(summary.updatedAtMs).toISOString(),
+    ...summary.state === "completed" ? { completedAt: new Date(summary.updatedAtMs).toISOString() } : {},
+    ...summary.cumulativeDurationMs !== void 0 ? { cumulativeDurationMs: summary.cumulativeDurationMs } : {},
+    ...summary.cumulativeUsage ? { cumulativeUsage: summary.cumulativeUsage } : {},
+    surface: surfaceFromConversationId(summary.conversationId),
+    title: titleFromSummary(summary),
+    ...requester ? { requester } : {},
+    ...summary.requester ? { requesterIdentity: summary.requester } : {},
+    ...slackThread ? { channel: slackThread.channelId } : {},
+    ...channelName ? { channelName } : {},
+    ...sentryConversationUrl ? { sentryConversationUrl } : {},
+    ...summary.traceId ? { traceId: summary.traceId } : {},
+    ...sentryTraceUrl ? { sentryTraceUrl } : {}
+  };
+}
+function canExposeConversationTranscript(summary) {
+  return canExposeConversationPayload({
+    conversationId: summary.conversationId
+  });
+}
+function textPart(text) {
+  return { type: "text", text };
+}
+function recordField(value, names) {
+  for (const name of names) {
+    if (value[name] !== void 0) {
+      return value[name];
+    }
+  }
+  return void 0;
+}
+function normalizeTranscriptPart(part) {
+  if (typeof part === "string") {
+    return textPart(part);
+  }
+  if (!isRecord(part)) {
+    return { type: "unknown", output: part };
+  }
+  const rawType = typeof part.type === "string" ? part.type : "unknown";
+  if (rawType === "text") {
+    const text = recordField(part, ["text", "content"]);
+    return textPart(
+      typeof text === "string" ? text : JSON.stringify(text) ?? ""
+    );
+  }
+  if (rawType === "toolCall") {
+    return {
+      type: "tool_call",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      input: recordField(part, ["arguments", "input", "args"])
+    };
+  }
+  if (rawType === "toolResult") {
+    return {
+      type: "tool_result",
+      ...typeof part.id === "string" ? { id: part.id } : {},
+      ...typeof part.name === "string" ? { name: part.name } : {},
+      output: recordField(part, ["result", "output", "content"])
+    };
+  }
+  if (rawType === "thinking") {
+    return {
+      type: "thinking",
+      output: recordField(part, ["thinking", "text", "content", "output"])
+    };
+  }
+  return {
+    type: rawType,
+    output: part
+  };
+}
+function normalizeToolResultMessage(record) {
+  const content = record.content;
+  let output = content;
+  if (Array.isArray(content) && content.length === 1 && isRecord(content[0])) {
+    const extracted = recordField(content[0], [
+      "text",
+      "content",
+      "output",
+      "result"
+    ]);
+    output = extracted !== void 0 ? extracted : content;
+  }
+  return {
+    type: "tool_result",
+    ...typeof record.toolCallId === "string" ? { id: record.toolCallId } : {},
+    ...typeof record.name === "string" ? { name: record.name } : typeof record.toolName === "string" ? { name: record.toolName } : {},
+    output
+  };
+}
+function normalizeTranscriptMessage(message) {
+  const record = message;
+  const content = record.content;
+  const role = typeof record.role === "string" ? record.role : "unknown";
+  return {
+    role,
+    ...typeof record.timestamp === "number" ? { timestamp: record.timestamp } : {},
+    parts: role === "toolResult" ? [normalizeToolResultMessage(record)] : Array.isArray(content) ? content.map(normalizeTranscriptPart) : [normalizeTranscriptPart(content)]
+  };
+}
+function serializedChars(value) {
+  if (typeof value === "string") return value.length;
+  return JSON.stringify(value)?.length ?? 0;
+}
+function serializedBytes(value) {
+  const serialized = typeof value === "string" ? value : JSON.stringify(value);
+  return new TextEncoder().encode(serialized ?? "").byteLength;
+}
+function payloadType(value) {
+  return Array.isArray(value) ? "array" : typeof value;
+}
+function payloadKeys(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const keys = Object.keys(value).slice(
+    0,
+    SAFE_METADATA_KEY_LIMIT
+  );
+  return keys.length > 0 ? keys : void 0;
+}
+function redactedPayloadFields(prefix, value) {
+  const keys = payloadKeys(value);
+  return {
+    [`${prefix}Type`]: payloadType(value),
+    [`${prefix}SizeBytes`]: serializedBytes(value),
+    [`${prefix}SizeChars`]: serializedChars(value),
+    ...keys ? { [`${prefix}Keys`]: keys } : {}
+  };
+}
+function redactTranscriptPart(part) {
+  if (part.type === "text") {
+    return {
+      type: "text",
+      redacted: true,
+      bytes: serializedBytes(part.text ?? ""),
+      chars: serializedChars(part.text ?? "")
+    };
+  }
+  if (part.type === "thinking") {
+    return {
+      type: "thinking",
+      redacted: true,
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  if (part.type === "tool_call") {
+    return {
+      type: "tool_call",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("input", part.input)
+    };
+  }
+  if (part.type === "tool_result") {
+    return {
+      type: "tool_result",
+      redacted: true,
+      ...part.id ? { id: part.id } : {},
+      ...part.name ? { name: part.name } : {},
+      ...redactedPayloadFields("output", part.output)
+    };
+  }
+  return {
+    type: part.type,
+    redacted: true,
+    ...redactedPayloadFields("output", part.output ?? part.input ?? part.text)
+  };
+}
+function redactTranscriptMessage(message) {
+  return {
+    role: message.role,
+    ...typeof message.timestamp === "number" ? { timestamp: message.timestamp } : {},
+    parts: message.parts.map(redactTranscriptPart)
+  };
+}
+function turnScopedMessages(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const record = messages[index];
+    if (record.role === "user") {
+      return messages.slice(index);
+    }
+  }
+  return messages;
+}
+function traceIdFromTranscript(transcript) {
+  for (const message of transcript) {
+    for (const part of message.parts) {
+      const text = part.text ?? (typeof part.output === "string" ? part.output : typeof part.input === "string" ? part.input : void 0);
+      const match = text?.match(
+        /\btrace[_-]?id["']?\s*[:=]\s*["']?([a-f0-9]{16,32})\b/i
+      );
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
+}
+async function readSessions() {
+  const summaries = await listAgentTurnSessionSummaries(50);
+  return {
+    source: "turn_session_records",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessions: summaries.map(sessionReportFromSummary)
+  };
+}
+async function readConversation(conversationId) {
+  const summaries = (await listAgentTurnSessionSummariesForConversation(conversationId)).sort(
+    (left, right) => left.startedAtMs - right.startedAtMs || left.updatedAtMs - right.updatedAtMs || left.sessionId.localeCompare(right.sessionId)
+  );
+  const turns = await Promise.all(
+    summaries.map(async (summary) => {
+      const sessionRecord = await getAgentTurnSessionRecord(
+        summary.conversationId,
+        summary.sessionId
+      );
+      const scopedMessages = sessionRecord?.piMessages ? turnScopedMessages(sessionRecord.piMessages) : [];
+      const canExposeTranscript = canExposeConversationTranscript(summary);
+      const normalizedTranscript = scopedMessages.map(
+        normalizeTranscriptMessage
+      );
+      const transcript = canExposeTranscript ? normalizedTranscript : [];
+      const transcriptMetadata = canExposeTranscript ? void 0 : normalizedTranscript.map(redactTranscriptMessage);
+      const traceId = summary.traceId ?? sessionRecord?.traceId ?? (canExposeTranscript ? traceIdFromTranscript(transcript) : void 0);
+      const sentryTraceUrl = traceId ? buildSentryTraceUrl(traceId) : void 0;
+      return {
+        ...sessionReportFromSummary(summary),
+        ...traceId ? { traceId } : {},
+        ...sentryTraceUrl ? { sentryTraceUrl } : {},
+        transcriptAvailable: Boolean(sessionRecord) && canExposeTranscript,
+        ...sessionRecord && scopedMessages.length > 0 ? { transcriptMessageCount: scopedMessages.length } : {},
+        ...!canExposeTranscript ? {
+          transcriptMetadata,
+          transcriptRedacted: true,
+          transcriptRedactionReason: "non_public_conversation"
+        } : {},
+        transcript
+      };
+    })
+  );
+  return {
+    conversationId,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    turns
+  };
+}
+function createJuniorReporting() {
+  return {
+    getHealth: readHealth,
+    async getRuntimeInfo() {
+      const [plugins, skills] = await Promise.all([
+        readPlugins(),
+        readSkills()
+      ]);
+      return {
+        cwd: process.cwd(),
+        homeDir: homeDir(),
+        descriptionText: readDescriptionText(),
+        providers: plugins.map((plugin) => plugin.name),
+        skills,
+        packagedContent: getPluginPackageContent()
+      };
+    },
+    getPlugins: readPlugins,
+    getSkills: readSkills,
+    getSessions: readSessions,
+    getConversation: readConversation
+  };
+}
+export {
+  createJuniorReporting
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@sentry/junior",
-  "version": "0.56.0",
+  "version": "0.58.0",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
+  "types": "./dist/app.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/getsentry/junior.git",
@@ -15,10 +16,26 @@
     "junior": "bin/junior.mjs"
   },
   "exports": {
-    ".": "./dist/app.js",
-    "./instrumentation": "./dist/instrumentation.js",
-    "./nitro": "./dist/nitro.js",
-    "./vercel": "./dist/vercel.js"
+    ".": {
+      "types": "./dist/app.d.ts",
+      "default": "./dist/app.js"
+    },
+    "./instrumentation": {
+      "types": "./dist/instrumentation.d.ts",
+      "default": "./dist/instrumentation.js"
+    },
+    "./nitro": {
+      "types": "./dist/nitro.d.ts",
+      "default": "./dist/nitro.js"
+    },
+    "./reporting": {
+      "types": "./dist/reporting.d.ts",
+      "default": "./dist/reporting.js"
+    },
+    "./vercel": {
+      "types": "./dist/vercel.d.ts",
+      "default": "./dist/vercel.js"
+    }
   },
   "files": [
     "dist",
@@ -35,6 +52,7 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "@sinclair/typebox": "^0.34.49",
     "@slack/web-api": "^7.16.0",
+    "@sentry/node": "10.53.1",
     "@vercel/functions": "^3.6.0",
     "@vercel/sandbox": "2.0.0",
     "ai": "^6.0.190",
@@ -46,13 +64,9 @@
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.56.0"
-  },
-  "peerDependencies": {
-    "@sentry/node": ">=10.0.0"
+    "@sentry/junior-plugin-api": "0.58.0"
   },
   "devDependencies": {
-    "@sentry/node": "10.53.1",
     "@types/node": "^25.9.1",
     "dependency-cruiser": "^17.4.0",
     "msw": "^2.14.6",
@@ -61,7 +75,8 @@
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.7",
+    "@sentry/junior-scheduler": "0.58.0"
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",

package/dist/chat/scheduler/cadence.d.ts

@@ -1,24 +0,0 @@
-import type { ScheduledCalendarFrequency, ScheduledTask, ScheduledTaskRecurrence } from "@/chat/scheduler/types";
-/** Parse an ISO timestamp into a finite Unix timestamp in milliseconds. */
-export declare function parseScheduleTimestamp(value: string): number | undefined;
-export interface ZonedDateTimeParts {
-    day: number;
-    hour: number;
-    minute: number;
-    month: number;
-    second: number;
-    weekday: number;
-    year: number;
-}
-/** Resolve a UTC timestamp into calendar parts for a named time zone. */
-export declare function getZonedDateTimeParts(timestampMs: number, timezone: string): ZonedDateTimeParts;
-/** Build a calendar recurrence anchored to an exact first run timestamp. */
-export declare function buildCalendarRecurrence(args: {
-    frequency: ScheduledCalendarFrequency;
-    interval?: number;
-    nextRunAtMs: number;
-    timezone: string;
-    weekdays?: number[];
-}): ScheduledTaskRecurrence;
-/** Return the next fire time after a completed run, when the task recurs. */
-export declare function getNextRunAtMs(task: ScheduledTask, scheduledForMs: number, afterMs?: number): number | undefined;

package/dist/chat/scheduler/plugin.d.ts

@@ -1,2 +0,0 @@
-/** Create Junior's built-in trusted scheduler plugin. */
-export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").JuniorPlugin;

package/dist/chat/scheduler/prompt.d.ts

@@ -1,7 +0,0 @@
-import { type ScheduledRun, type ScheduledTask } from "@/chat/scheduler/types";
-/** Build the marker-delimited user prompt for one scheduled task execution. */
-export declare function buildScheduledTaskRunPrompt(args: {
-    nowMs: number;
-    run: ScheduledRun;
-    task: ScheduledTask;
-}): string;