@sentry/junior 0.202.0 → 0.204.0

package/dist/chunk-QB54UQUS.js

@@ -1,320 +0,0 @@
-import {
-  parseSandboxEgressAuthRequiredSignal
-} from "./chunk-6Y5B5PEX.js";
-import {
-  authorizationId
-} from "./chunk-DIB4GX3G.js";
-import {
-  formatProviderLabel,
-  startOAuthFlow
-} from "./chunk-DL2KLKVH.js";
-import {
-  abandonReplacedPendingAuth,
-  canReusePendingAuthLink
-} from "./chunk-ELWOYVOY.js";
-import {
-  recordAuthorizationRequested
-} from "./chunk-5PKWYPFT.js";
-import {
-  AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-PW4P4JYF.js";
-import {
-  TURN_REASONING_LEVELS
-} from "./chunk-NHJU2ZAL.js";
-import {
-  pluginCatalogRuntime
-} from "./chunk-YDUR3ZYW.js";
-import {
-  credentialContextSchema
-} from "./chunk-CEMMLV5L.js";
-
-// src/chat/services/auth-pause.ts
-var AuthorizationPauseError = class extends Error {
-  disposition;
-  kind;
-  provider;
-  providerDisplayName;
-  requestText;
-  constructor(kind, provider, providerDisplayName, disposition, requestText) {
-    super(
-      kind === "mcp" ? `MCP authorization started for ${provider}` : `Plugin authorization started for ${provider}`
-    );
-    this.name = kind === "mcp" ? "McpAuthorizationPauseError" : "PluginAuthorizationPauseError";
-    this.disposition = disposition;
-    this.kind = kind;
-    this.provider = provider;
-    this.providerDisplayName = providerDisplayName;
-    this.requestText = requestText;
-  }
-};
-var AuthPausePersistenceError = class extends Error {
-  constructor(conversationId, turnId, cause) {
-    super(
-      `Failed to persist auth pause for conversation=${conversationId} turn=${turnId}`,
-      cause === void 0 ? void 0 : { cause }
-    );
-    this.name = "AuthPausePersistenceError";
-  }
-};
-var AuthorizationFlowDisabledError = class extends Error {
-  kind;
-  provider;
-  constructor(kind, provider) {
-    super(
-      `Authorization is required for ${provider}, but this turn cannot start an authorization flow.`
-    );
-    this.name = "AuthorizationFlowDisabledError";
-    this.kind = kind;
-    this.provider = provider;
-  }
-};
-
-// src/chat/services/plugin-auth-orchestration.ts
-var PluginAuthorizationPauseError = class extends AuthorizationPauseError {
-  constructor(provider, providerDisplayName, disposition, requestText) {
-    super("plugin", provider, providerDisplayName, disposition, requestText);
-  }
-};
-var PluginCredentialFailureError = class extends Error {
-  provider;
-  constructor(provider, message) {
-    super(message);
-    this.name = "PluginCredentialFailureError";
-    this.provider = provider;
-  }
-};
-function pluginAuthRequiredSignal(details) {
-  if (!details || typeof details !== "object") {
-    return void 0;
-  }
-  const signal = details.auth_required;
-  const parsedSignal = parseSandboxEgressAuthRequiredSignal(signal);
-  if (!parsedSignal) {
-    return void 0;
-  }
-  return {
-    provider: parsedSignal.provider,
-    grant: parsedSignal.grant,
-    kind: parsedSignal.kind,
-    ...parsedSignal.message ? { message: parsedSignal.message } : void 0,
-    ...parsedSignal.authorization ? { authorization: parsedSignal.authorization } : void 0
-  };
-}
-function createPluginAuthOrchestration(input) {
-  let pendingPause;
-  const startAuthorizationPause = async (provider, options) => {
-    if (pendingPause) {
-      throw pendingPause;
-    }
-    if (!input.actorId || !pluginCatalogRuntime.getOAuthConfig(provider)) {
-      throw new Error(`Cannot start plugin authorization for ${provider}`);
-    }
-    if (input.interactiveAuthEnabled === false) {
-      throw new AuthorizationFlowDisabledError("plugin", provider);
-    }
-    const recordPendingAuth = input.sessionId ? input.recordPendingAuth : void 0;
-    if (input.sessionId && !recordPendingAuth) {
-      throw new Error(
-        `Missing pending auth recorder for plugin authorization pause "${provider}"`
-      );
-    }
-    const providerLabel = formatProviderLabel(provider);
-    const reusingPendingLink = input.sessionId ? canReusePendingAuthLink({
-      pendingAuth: input.pendingAuth,
-      kind: "plugin",
-      provider,
-      actorId: input.actorId,
-      sessionId: input.sessionId,
-      ...options?.scope ? { scope: options.scope } : void 0
-    }) : false;
-    if (!reusingPendingLink) {
-      const oauthResult = await startOAuthFlow(provider, {
-        actorId: input.actorId,
-        ...input.actor ? { actor: input.actor } : void 0,
-        channelId: input.channelId,
-        destination: input.destination,
-        source: input.source,
-        threadTs: input.threadTs,
-        ...options?.scope ? { scope: options.scope } : void 0,
-        resumeConversationId: input.conversationId,
-        resumeSessionId: input.sessionId,
-        authorization: input.authorization
-      });
-      if (!oauthResult.ok) {
-        throw new Error(oauthResult.error);
-      }
-      if (!oauthResult.delivery) {
-        throw new Error(
-          `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
-        );
-      }
-    }
-    if (input.sessionId && recordPendingAuth) {
-      const nextPendingAuth = {
-        kind: "plugin",
-        provider,
-        actorId: input.actorId,
-        ...options?.scope ? { scope: options.scope } : void 0,
-        sessionId: input.sessionId,
-        linkSentAtMs: reusingPendingLink ? input.pendingAuth.linkSentAtMs : Date.now()
-      };
-      await recordPendingAuth(nextPendingAuth);
-      await abandonReplacedPendingAuth({
-        conversationId: input.conversationId,
-        previousPendingAuth: input.pendingAuth,
-        nextPendingAuth
-      });
-    }
-    if (input.conversationId && input.sessionId) {
-      await recordAuthorizationRequested({
-        conversationId: input.conversationId,
-        kind: "plugin",
-        provider,
-        actorId: input.actorId,
-        authorizationId: authorizationId({
-          kind: "plugin",
-          provider,
-          sessionId: input.sessionId
-        }),
-        delivery: reusingPendingLink ? "private_link_reused" : "private_link_sent"
-      });
-    }
-    pendingPause = new PluginAuthorizationPauseError(
-      provider,
-      providerLabel,
-      reusingPendingLink ? "link_already_sent" : "link_sent",
-      input.userMessage
-    );
-    input.abortAgent();
-    throw pendingPause;
-  };
-  return {
-    maybeHandleAuthSignal: async (details) => {
-      const signal = pluginAuthRequiredSignal(details);
-      if (!signal) {
-        return;
-      }
-      const { provider, authorization } = signal;
-      if (signal.kind === "unavailable") {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are unavailable.`
-        );
-      }
-      if (!authorization) {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required but no OAuth flow is available for this provider.`
-        );
-      }
-      if (!input.actorId || !input.userTokenStore) {
-        if (input.interactiveAuthEnabled === false) {
-          throw new AuthorizationFlowDisabledError("plugin", provider);
-        }
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required. Please connect your ${formatProviderLabel(provider)} account and try again.`
-        );
-      }
-      if (!pluginCatalogRuntime.getOAuthConfig(authorization.provider)) {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required but the provider is not configured for OAuth.`
-        );
-      }
-      await startAuthorizationPause(
-        authorization.provider,
-        authorization.scope ? { scope: authorization.scope } : void 0
-      );
-    },
-    getPendingPause: () => pendingPause
-  };
-}
-
-// src/chat/agent-invocations/errors.ts
-var AgentInvocationBusyError = class extends Error {
-  constructor(name) {
-    super(`Named agent "${name}" already has active work`);
-    this.name = "AgentInvocationBusyError";
-  }
-};
-var AgentInvocationLimitError = class extends Error {
-  constructor(limit) {
-    super(
-      `Parent already has ${limit} active child agent invocations (limit ${limit})`
-    );
-    this.name = "AgentInvocationLimitError";
-  }
-};
-
-// src/chat/agent-invocations/types.ts
-import {
-  actorSchema,
-  destinationSchema,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-import { z } from "zod";
-var exactStringSchema = z.string().min(1).refine((value) => value === value.trim());
-var agentNameSchema = exactStringSchema.max(64);
-var agentInvocationMailboxStatusSchema = z.enum(
-  AGENT_INVOCATION_MAILBOX_STATUSES
-);
-var agentBindingSchema = z.object({
-  childConversationId: exactStringSchema,
-  name: agentNameSchema,
-  parentConversationId: exactStringSchema
-}).strict();
-var agentInvocationBaseSchema = z.object({
-  actor: actorSchema,
-  agentName: agentNameSchema.optional(),
-  childConversationId: exactStringSchema,
-  createdAtMs: z.number().finite(),
-  credentialContext: credentialContextSchema.optional(),
-  destination: destinationSchema,
-  input: exactStringSchema,
-  invocationId: exactStringSchema,
-  mailboxStatus: agentInvocationMailboxStatusSchema,
-  parentConversationId: exactStringSchema,
-  reasoningLevel: z.enum(TURN_REASONING_LEVELS).optional(),
-  source: sourceSchema,
-  updatedAtMs: z.number().finite()
-}).strict();
-var agentInvocationSchema = z.discriminatedUnion("status", [
-  agentInvocationBaseSchema.extend({
-    status: z.enum(["pending", "running", "awaiting_resume"])
-  }),
-  agentInvocationBaseSchema.extend({
-    result: z.string(),
-    status: z.literal("completed"),
-    terminalAtMs: z.number().finite()
-  }),
-  agentInvocationBaseSchema.extend({
-    errorMessage: z.string(),
-    status: z.enum(["blocked", "failed"]),
-    terminalAtMs: z.number().finite()
-  })
-]);
-var createAgentInvocationSchema = z.object({
-  actor: actorSchema,
-  agentName: agentNameSchema.optional(),
-  credentialContext: credentialContextSchema.optional(),
-  destination: destinationSchema,
-  idempotencyKey: exactStringSchema,
-  input: exactStringSchema,
-  parentConversationId: exactStringSchema,
-  reasoningLevel: z.enum(TURN_REASONING_LEVELS).optional()
-}).strict();
-
-export {
-  AuthorizationPauseError,
-  AuthPausePersistenceError,
-  AuthorizationFlowDisabledError,
-  AgentInvocationBusyError,
-  AgentInvocationLimitError,
-  agentNameSchema,
-  agentBindingSchema,
-  agentInvocationSchema,
-  createAgentInvocationSchema,
-  PluginCredentialFailureError,
-  createPluginAuthOrchestration
-};

package/dist/chunk-QP3OGJXF.js

@@ -1,105 +0,0 @@
-import {
-  getStateAdapter
-} from "./chunk-2MK3QBGA.js";
-import {
-  getClient
-} from "./chunk-PEQXYSSE.js";
-
-// src/chat/conversations/web-authorization.ts
-import { randomUUID } from "crypto";
-var WEB_AUTHORIZATION_PREFIX = "junior:web_authorization:v1";
-var WEB_AUTHORIZATION_TTL_MS = 24 * 60 * 60 * 1e3;
-function authorizationKey(conversationId, actorId) {
-  return `${WEB_AUTHORIZATION_PREFIX}:${conversationId}:${actorId}`;
-}
-function createWebAuthorization(args) {
-  return {
-    createState: async () => randomUUID(),
-    deliver: async (request) => {
-      await getStateAdapter().set(
-        authorizationKey(args.conversationId, args.actorId),
-        JSON.stringify({ ...request, ...args }),
-        WEB_AUTHORIZATION_TTL_MS
-      );
-    }
-  };
-}
-async function getWebAuthorization(args) {
-  const value = await getStateAdapter().get(
-    authorizationKey(args.conversationId, args.actorId)
-  );
-  if (typeof value !== "string") return void 0;
-  try {
-    const parsed = JSON.parse(value);
-    if (parsed.actorId !== args.actorId || parsed.conversationId !== args.conversationId || typeof parsed.authorizationUrl !== "string" || typeof parsed.label !== "string" || typeof parsed.completionText !== "string") {
-      return void 0;
-    }
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-async function deleteWebAuthorization(args) {
-  await getStateAdapter().delete(
-    authorizationKey(args.conversationId, args.actorId)
-  );
-}
-
-// src/chat/sentry-links.ts
-function getSentryOrgSlug() {
-  const slug = process.env.SENTRY_ORG_SLUG?.trim();
-  return slug || void 0;
-}
-function isSentrySaasDsnHost(host) {
-  return host === "sentry.io" || host.endsWith(".sentry.io");
-}
-function buildSentryWebBaseUrl(dsn) {
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return "https://sentry.io";
-  }
-  const port = dsn.port ? `:${dsn.port}` : "";
-  const path = dsn.path ? `/${dsn.path}` : "";
-  return `${dsn.protocol}://${dsn.host}${port}${path}`;
-}
-function buildSentryOrgPath(args) {
-  const client = getClient();
-  const dsn = client?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  if (args.query) {
-    for (const [key, value] of Object.entries(args.query)) {
-      params.set(key, value);
-    }
-  }
-  const path = `${args.path}?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
-}
-function buildSentryConversationUrl(conversationId) {
-  return buildSentryOrgPath({
-    path: `explore/conversations/${encodeURIComponent(conversationId)}/`
-  });
-}
-function buildSentryEventUrl(eventId) {
-  return buildSentryOrgPath({
-    path: "issues/",
-    query: { query: eventId }
-  });
-}
-
-export {
-  buildSentryConversationUrl,
-  buildSentryEventUrl,
-  createWebAuthorization,
-  getWebAuthorization,
-  deleteWebAuthorization
-};

package/dist/chunk-RC745GGZ.js

@@ -1,122 +0,0 @@
-// src/reporting-schema.ts
-import { z } from "zod";
-var healthReportSchema = z.object({
-  status: z.literal("ok"),
-  service: z.string(),
-  timestamp: z.string()
-}).strict();
-var pluginSchema = z.object({
-  configKeys: z.array(z.string()),
-  description: z.string(),
-  displayName: z.string(),
-  name: z.string()
-}).strict();
-var pluginsSchema = z.array(pluginSchema);
-var skillReportSchema = z.object({
-  name: z.string(),
-  pluginProvider: z.string().optional()
-}).strict();
-var skillReportsSchema = z.array(skillReportSchema);
-var pluginPackageContentItemReportSchema = z.object({
-  dir: z.string(),
-  hasMigrationsDir: z.boolean(),
-  hasSkillsDir: z.boolean(),
-  packageName: z.string()
-}).strict();
-var pluginPackageContentReportSchema = z.object({
-  packageNames: z.array(z.string()),
-  packages: z.array(pluginPackageContentItemReportSchema),
-  manifestRoots: z.array(z.string()),
-  skillRoots: z.array(z.string()),
-  tracingIncludes: z.array(z.string())
-}).strict();
-var runtimeInfoReportSchema = z.object({
-  cwd: z.string(),
-  homeDir: z.string(),
-  descriptionText: z.string().optional(),
-  providers: z.array(z.string()),
-  skills: z.array(skillReportSchema),
-  packagedContent: pluginPackageContentReportSchema
-}).strict();
-var pluginOperationalToneSchema = z.enum([
-  "danger",
-  "good",
-  "neutral",
-  "warning"
-]);
-var pluginOperationalMetricSchema = z.object({
-  label: z.string(),
-  tone: pluginOperationalToneSchema.optional(),
-  value: z.string()
-}).strict();
-var pluginOperationalFieldSchema = z.object({
-  key: z.string(),
-  label: z.string()
-}).strict();
-var pluginOperationalRecordSchema = z.object({
-  id: z.string(),
-  tone: pluginOperationalToneSchema.optional(),
-  values: z.record(z.string(), z.string())
-}).strict();
-var pluginOperationalRecordSetSchema = z.object({
-  fields: z.array(pluginOperationalFieldSchema).optional(),
-  emptyText: z.string().optional(),
-  records: z.array(pluginOperationalRecordSchema).optional(),
-  title: z.string()
-}).strict();
-var pluginOperationalBarChartWidgetSchema = z.object({
-  categories: z.array(
-    z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      values: z.record(z.string(), z.number().finite())
-    }).strict()
-  ).max(100),
-  description: z.string().optional(),
-  emptyText: z.string().optional(),
-  id: z.string().min(1),
-  series: z.array(
-    z.object({
-      format: z.literal("usd").optional(),
-      key: z.string().min(1),
-      label: z.string().min(1),
-      tone: pluginOperationalToneSchema.optional()
-    }).strict()
-  ).min(1).max(8),
-  timeRangeDays: z.array(
-    z.union([
-      z.literal(1),
-      z.literal(7),
-      z.literal(30),
-      z.literal(90)
-    ])
-  ).min(1).max(4).optional(),
-  title: z.string().min(1),
-  type: z.literal("bar_chart")
-}).strict();
-var pluginOperationalReportSchema = z.object({
-  generatedAt: z.string().optional(),
-  metrics: z.array(pluginOperationalMetricSchema).optional(),
-  recordSets: z.array(pluginOperationalRecordSetSchema).optional(),
-  title: z.string().optional(),
-  pluginName: z.string(),
-  widgets: z.array(pluginOperationalBarChartWidgetSchema).max(12).optional()
-}).strict();
-var pluginOperationalReportFeedSchema = z.object({
-  generatedAt: z.string(),
-  reports: z.array(pluginOperationalReportSchema),
-  source: z.literal("plugins")
-}).strict();
-
-export {
-  healthReportSchema,
-  pluginSchema,
-  pluginsSchema,
-  skillReportSchema,
-  skillReportsSchema,
-  pluginPackageContentItemReportSchema,
-  pluginPackageContentReportSchema,
-  runtimeInfoReportSchema,
-  pluginOperationalReportSchema,
-  pluginOperationalReportFeedSchema
-};

package/dist/chunk-REOIRYPR.js

@@ -1,37 +0,0 @@
-import {
-  createAndEnqueueAgentInvocation
-} from "./chunk-3PGQSKJV.js";
-import {
-  actorFromRun,
-  toolInvocationDestination
-} from "./chunk-DL2KLKVH.js";
-
-// src/chat/agent-invocations/spawn.ts
-function bindSpawnAgent(run, options) {
-  const actor = actorFromRun(run);
-  if (!actor) {
-    return void 0;
-  }
-  return async (input, call) => {
-    call.signal?.throwIfAborted();
-    const queue = typeof options.queue === "function" ? options.queue() : options.queue;
-    const invocation = await createAndEnqueueAgentInvocation(
-      {
-        actor,
-        ...input.name ? { agentName: input.name } : void 0,
-        ...run.credentialContext ? { credentialContext: run.credentialContext } : void 0,
-        destination: toolInvocationDestination(run),
-        idempotencyKey: `${run.turnId}:${call.toolCallId}`,
-        input: input.task,
-        parentConversationId: run.conversationId,
-        ...input.reasoningLevel ? { reasoningLevel: input.reasoningLevel } : void 0
-      },
-      { ...options, queue }
-    );
-    return { invocationId: invocation.invocationId };
-  };
-}
-
-export {
-  bindSpawnAgent
-};