@sentry/junior 0.117.0 → 0.118.0

package/migrations/meta/_journal.json

@@ -78,6 +78,13 @@
       "when": 1785211716838,
       "tag": "0010_native_conversation_history",
       "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "7",
+      "when": 1785271740428,
+      "tag": "0011_sour_golden_guardian",
+      "breakpoints": true
     }
   ]
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -78,7 +78,7 @@
     "pg": "^8.16.3",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@sentry/junior-plugin-api": "0.117.0"
+    "@sentry/junior-plugin-api": "0.118.0"
   },
   "devDependencies": {
     "@emnapi/core": "^1.10.0",
@@ -95,9 +95,9 @@
     "typescript": "^6.0.3",
     "vercel": "^54.4.0",
     "vitest": "^4.1.7",
-    "@sentry/junior-github": "0.117.0",
-    "@sentry/junior-memory": "0.117.0",
-    "@sentry/junior-scheduler": "0.117.0",
+    "@sentry/junior-github": "0.118.0",
+    "@sentry/junior-scheduler": "0.118.0",
+    "@sentry/junior-memory": "0.118.0",
     "@sentry/junior-testing": "0.0.0"
   },
   "scripts": {

package/dist/chunk-4ZNGQH7C.js

@@ -1,25 +0,0 @@
-// src/chat/sleep.ts
-function sleep(ms, signal) {
-  if (!signal) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(signal.reason);
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timeoutId);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-export {
-  sleep
-};

package/dist/chunk-YRWJ3KEU.js

@@ -1,517 +0,0 @@
-import {
-  juniorConversationAnnotations
-} from "./chunk-RXRQJF7Y.js";
-import {
-  sleep
-} from "./chunk-4ZNGQH7C.js";
-import {
-  getSlackBotToken
-} from "./chunk-DS27ZBSP.js";
-import {
-  logWarn,
-  setSpanAttributes,
-  setSpanStatus,
-  withSpan
-} from "./chunk-72Z3HNTQ.js";
-import {
-  parseSlackChannelReferenceId
-} from "./chunk-F3B2YJ76.js";
-
-// src/chat/plugins/annotations.ts
-import { and, desc, eq } from "drizzle-orm";
-import {
-  conversationAnnotationInputSchema
-} from "@sentry/junior-plugin-api";
-function createPluginAnnotations(args) {
-  return {
-    async upsert(input) {
-      const annotation = conversationAnnotationInputSchema.parse(input);
-      const now = /* @__PURE__ */ new Date();
-      await args.db.insert(juniorConversationAnnotations).values({
-        annotation,
-        conversationId: args.conversationId,
-        createdAt: now,
-        key: annotation.key,
-        kind: annotation.kind,
-        plugin: args.plugin,
-        updatedAt: now
-      }).onConflictDoUpdate({
-        target: [
-          juniorConversationAnnotations.conversationId,
-          juniorConversationAnnotations.plugin,
-          juniorConversationAnnotations.kind,
-          juniorConversationAnnotations.key
-        ],
-        set: { annotation, updatedAt: now }
-      });
-    },
-    async remove(kind, key) {
-      await args.db.delete(juniorConversationAnnotations).where(
-        and(
-          eq(
-            juniorConversationAnnotations.conversationId,
-            args.conversationId
-          ),
-          eq(juniorConversationAnnotations.plugin, args.plugin),
-          eq(juniorConversationAnnotations.kind, kind),
-          eq(juniorConversationAnnotations.key, key)
-        )
-      );
-    },
-    async list() {
-      return (await listConversationAnnotations(args.db, args.conversationId)).filter((a) => a.plugin === args.plugin);
-    }
-  };
-}
-async function listConversationAnnotations(db, conversationId) {
-  const rows = await db.select().from(juniorConversationAnnotations).where(eq(juniorConversationAnnotations.conversationId, conversationId)).orderBy(desc(juniorConversationAnnotations.updatedAt));
-  return rows.flatMap((row) => {
-    const parsed = conversationAnnotationInputSchema.safeParse(row.annotation);
-    return parsed.success ? [
-      {
-        ...parsed.data,
-        plugin: row.plugin,
-        createdAt: row.createdAt.toISOString(),
-        updatedAt: row.updatedAt.toISOString()
-      }
-    ] : [];
-  });
-}
-
-// src/chat/slack/client.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { WebClient } from "@slack/web-api";
-
-// src/chat/slack/workspace-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var workspaceTeamIdStorage = new AsyncLocalStorage();
-function runWithWorkspaceTeamId(teamId, fn) {
-  if (!teamId) return fn();
-  return workspaceTeamIdStorage.run(teamId, fn);
-}
-function getWorkspaceTeamId() {
-  return workspaceTeamIdStorage.getStore();
-}
-
-// src/chat/slack/client.ts
-var SlackActionError = class extends Error {
-  code;
-  apiError;
-  needed;
-  provided;
-  statusCode;
-  requestId;
-  errorData;
-  retryAfterSeconds;
-  detail;
-  detailLine;
-  detailRule;
-  constructor(message, code, options = {}) {
-    super(message);
-    this.name = "SlackActionError";
-    this.code = code;
-    this.apiError = options.apiError;
-    this.needed = options.needed;
-    this.provided = options.provided;
-    this.statusCode = options.statusCode;
-    this.requestId = options.requestId;
-    this.errorData = options.errorData;
-    this.retryAfterSeconds = options.retryAfterSeconds;
-    this.detail = options.detail;
-    this.detailLine = options.detailLine;
-    this.detailRule = options.detailRule;
-  }
-};
-function serializeSlackErrorData(data) {
-  if (!data || typeof data !== "object") {
-    return void 0;
-  }
-  const filtered = Object.fromEntries(
-    Object.entries(data).filter(
-      ([key]) => key !== "error"
-    )
-  );
-  if (Object.keys(filtered).length === 0) {
-    return void 0;
-  }
-  try {
-    const serialized = JSON.stringify(filtered);
-    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
-  } catch {
-    return void 0;
-  }
-}
-function getHeaderString(headers, name) {
-  if (!headers || typeof headers !== "object") {
-    return void 0;
-  }
-  const key = name.toLowerCase();
-  const entries = headers;
-  for (const [entryKey, value] of Object.entries(entries)) {
-    if (entryKey.toLowerCase() !== key) continue;
-    if (typeof value === "string") return value;
-    if (Array.isArray(value)) {
-      const first = value.find((entry) => typeof entry === "string");
-      return typeof first === "string" ? first : void 0;
-    }
-  }
-  return void 0;
-}
-function parseSlackCanvasDetail(detail) {
-  if (typeof detail !== "string") {
-    return {};
-  }
-  const trimmed = detail.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const parsed = {
-    detail: trimmed
-  };
-  const lineMatch = trimmed.match(/line\s+(\d+):/i);
-  if (lineMatch) {
-    const line = Number.parseInt(lineMatch[1] ?? "", 10);
-    if (Number.isFinite(line)) {
-      parsed.detailLine = line;
-    }
-  }
-  if (/unsupported heading depth/i.test(trimmed)) {
-    parsed.detailRule = "unsupported_heading_depth";
-  }
-  return parsed;
-}
-var installationTokenStorage = new AsyncLocalStorage2();
-var clientsByToken = /* @__PURE__ */ new Map();
-function runWithSlackInstallationToken(token, fn) {
-  const trimmed = token.trim();
-  if (!trimmed) {
-    throw new SlackActionError(
-      "Slack installation token binding requires a non-empty token",
-      "missing_token"
-    );
-  }
-  return installationTokenStorage.run({ token: trimmed }, fn);
-}
-function resolveSlackToken() {
-  const ambientToken = installationTokenStorage.getStore()?.token;
-  if (ambientToken) {
-    return ambientToken;
-  }
-  const envToken = getSlackBotToken();
-  if (envToken) {
-    return envToken;
-  }
-  const teamId = getWorkspaceTeamId();
-  if (teamId) {
-    throw new SlackActionError(
-      `Slack call is scoped to workspace ${teamId} but no installation token is bound and no default bot token is configured`,
-      "missing_token"
-    );
-  }
-  throw new SlackActionError(
-    "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack Web API actions in this service",
-    "missing_token"
-  );
-}
-function normalizeSlackConversationId(channelId) {
-  return parseSlackChannelReferenceId(channelId);
-}
-function getClient() {
-  const token = resolveSlackToken();
-  let cached = clientsByToken.get(token);
-  if (!cached) {
-    cached = new WebClient(token, {
-      retryConfig: { retries: 0 },
-      rejectRateLimitedCalls: true
-    });
-    clientsByToken.set(token, cached);
-  }
-  return cached;
-}
-function mapSlackError(error) {
-  if (error instanceof SlackActionError) {
-    return error;
-  }
-  const candidate = error;
-  const apiError = candidate.data?.error;
-  const message = candidate.message ?? "Slack action failed";
-  const baseOptions = {
-    apiError,
-    statusCode: candidate.statusCode,
-    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
-    errorData: serializeSlackErrorData(candidate.data),
-    ...parseSlackCanvasDetail(candidate.data?.detail)
-  };
-  if (apiError === "missing_scope") {
-    return new SlackActionError(message, "missing_scope", {
-      ...baseOptions,
-      needed: candidate.data?.needed,
-      provided: candidate.data?.provided
-    });
-  }
-  if (apiError === "not_in_channel") {
-    return new SlackActionError(message, "not_in_channel", baseOptions);
-  }
-  if (apiError === "restricted_action_read_only_channel") {
-    return new SlackActionError(message, "read_only_channel", baseOptions);
-  }
-  if (apiError === "already_reacted") {
-    return new SlackActionError(message, "already_reacted", baseOptions);
-  }
-  if (apiError === "no_reaction") {
-    return new SlackActionError(message, "no_reaction", baseOptions);
-  }
-  if (apiError === "invalid_arguments") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_cursor") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_name") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
-    return new SlackActionError(message, "not_found", baseOptions);
-  }
-  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
-    return new SlackActionError(message, "feature_unavailable", baseOptions);
-  }
-  if (apiError === "canvas_creation_failed") {
-    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
-  }
-  if (apiError === "canvas_editing_failed") {
-    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
-  }
-  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
-    return new SlackActionError(message, "rate_limited", {
-      ...baseOptions,
-      retryAfterSeconds: candidate.retryAfter
-    });
-  }
-  return new SlackActionError(message, "internal_error", baseOptions);
-}
-var MAX_RETRY_DELAY_MS = 1e4;
-var MAX_TOTAL_RETRY_DELAY_MS = 2e4;
-var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EAI_AGAIN"
-]);
-var TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ETIMEDOUT",
-  "ECONNABORTED",
-  "ESOCKETTIMEDOUT"
-]);
-function findNetworkErrorCode(error, depth = 0) {
-  if (!error || typeof error !== "object" || depth > 4) {
-    return void 0;
-  }
-  const candidate = error;
-  if (typeof candidate.code === "string" && (CONNECTION_ERROR_CODES.has(candidate.code) || TIMEOUT_ERROR_CODES.has(candidate.code))) {
-    return candidate.code;
-  }
-  return findNetworkErrorCode(candidate.original, depth + 1) ?? findNetworkErrorCode(candidate.cause, depth + 1);
-}
-function hasSocketHangUpMessage(error) {
-  return error instanceof Error && error.message.toLowerCase().includes("socket hang up");
-}
-function classifySlackRetry(raw, mapped) {
-  if (mapped.code === "rate_limited") {
-    return "rate_limited";
-  }
-  if (mapped.statusCode !== void 0 && mapped.statusCode >= 500) {
-    return "server_error";
-  }
-  const networkCode = findNetworkErrorCode(raw);
-  if (networkCode && CONNECTION_ERROR_CODES.has(networkCode)) {
-    return "connection";
-  }
-  if (networkCode && TIMEOUT_ERROR_CODES.has(networkCode)) {
-    return "timeout";
-  }
-  if (hasSocketHangUpMessage(raw)) {
-    return "connection";
-  }
-  return "none";
-}
-async function withSlackRetries(task, maxAttempts = 3, context = {}) {
-  let attempt = 0;
-  let totalDelayMs = 0;
-  const action = context.action ?? "unknown";
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    const attemptNumber = attempt;
-    try {
-      return await withSpan(
-        `POST slack.com/api/${action}`,
-        "http.client",
-        {},
-        async () => {
-          try {
-            return await task();
-          } catch (error) {
-            const mapped = mapSlackError(error);
-            const errorAttrs = {
-              "error.type": mapped.code
-            };
-            if (mapped.apiError) {
-              errorAttrs["app.slack.api_error_code"] = mapped.apiError;
-            }
-            if (mapped.code === "rate_limited") {
-              errorAttrs["http.response.status_code"] = 429;
-              if (mapped.retryAfterSeconds) {
-                errorAttrs["app.slack.retry_after_ms"] = mapped.retryAfterSeconds * 1e3;
-              }
-            } else if (mapped.statusCode != null) {
-              errorAttrs["http.response.status_code"] = mapped.statusCode;
-            }
-            setSpanAttributes(errorAttrs);
-            setSpanStatus("error");
-            throw error;
-          }
-        },
-        {
-          "http.request.method": "POST",
-          "server.address": "slack.com",
-          "url.scheme": "https",
-          "url.path": `/api/${action}`,
-          "app.slack.method": action,
-          "app.retry.max_attempts": maxAttempts,
-          ...attemptNumber > 1 ? { "http.resend_count": attemptNumber - 1 } : {},
-          ...context.attributes ?? {},
-          ...context.spanAttributes ?? {}
-        }
-      );
-    } catch (error) {
-      const mapped = mapSlackError(error);
-      const retryClass = classifySlackRetry(error, mapped);
-      const isRetryable = retryClass === "rate_limited" || retryClass === "connection" || retryClass === "server_error" || retryClass === "timeout" && context.idempotent === true;
-      const remainingDelayBudgetMs = MAX_TOTAL_RETRY_DELAY_MS - totalDelayMs;
-      const baseLogAttributes = {
-        "app.slack.action": action,
-        "app.slack.error_code": mapped.code,
-        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
-        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
-        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
-        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
-        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
-        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
-        ...context.attributes ?? {}
-      };
-      if (!isRetryable || attempt >= maxAttempts || remainingDelayBudgetMs <= 0) {
-        logWarn(
-          "slack_action_failed",
-          {},
-          {
-            ...baseLogAttributes,
-            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
-          },
-          "Slack action failed"
-        );
-        throw mapped;
-      }
-      logWarn(
-        "slack_action_retrying",
-        {},
-        {
-          ...baseLogAttributes,
-          "app.slack.retry_attempt": attempt,
-          "app.slack.retry_class": retryClass
-        },
-        "Retrying Slack action after transient failure"
-      );
-      const retryAfterMs = retryClass === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
-      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
-      const delayMs = Math.min(
-        retryAfterMs ?? backoffMs,
-        MAX_RETRY_DELAY_MS,
-        remainingDelayBudgetMs
-      );
-      totalDelayMs += delayMs;
-      await sleep(delayMs);
-    }
-  }
-  throw new SlackActionError(
-    "Slack action exhausted retries",
-    "internal_error"
-  );
-}
-function getSlackClient() {
-  return getClient();
-}
-function isDmChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  return Boolean(normalized && normalized.startsWith("D"));
-}
-function isConversationScopedChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
-}
-function isConversationChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G");
-}
-async function getFilePermalink(fileId) {
-  const client = getClient();
-  const response = await withSlackRetries(
-    () => client.files.info({
-      file: fileId
-    }),
-    3,
-    {
-      action: "files.info",
-      idempotent: true,
-      spanAttributes: { "app.slack.file_id": fileId }
-    }
-  );
-  return response.file?.permalink;
-}
-async function downloadPrivateSlackFile(url) {
-  const token = resolveSlackToken();
-  return withSpan(
-    "GET files.slack.com",
-    "http.client",
-    {},
-    async () => {
-      const response = await fetch(url, {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
-      });
-      setSpanAttributes({ "http.response.status_code": response.status });
-      if (!response.ok) {
-        setSpanAttributes({ "error.type": String(response.status) });
-        setSpanStatus("error");
-        throw new Error(`Slack file download failed: ${response.status}`);
-      }
-      return Buffer.from(await response.arrayBuffer());
-    },
-    {
-      "http.request.method": "GET",
-      "server.address": "files.slack.com",
-      "url.scheme": "https",
-      "app.slack.method": "files.download"
-    }
-  );
-}
-
-export {
-  createPluginAnnotations,
-  listConversationAnnotations,
-  runWithWorkspaceTeamId,
-  getWorkspaceTeamId,
-  SlackActionError,
-  getHeaderString,
-  runWithSlackInstallationToken,
-  normalizeSlackConversationId,
-  withSlackRetries,
-  getSlackClient,
-  isDmChannel,
-  isConversationScopedChannel,
-  isConversationChannel,
-  getFilePermalink,
-  downloadPrivateSlackFile
-};