@sentry/junior 0.67.3 → 0.69.0

package/dist/chunk-76YMBKW7.js

@@ -0,0 +1,326 @@
+import {
+  getSlackBotToken
+} from "./chunk-JS4HURDT.js";
+import {
+  logWarn
+} from "./chunk-BBXYXOJW.js";
+
+// src/chat/slack/client.ts
+import { WebClient } from "@slack/web-api";
+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 client = null;
+function normalizeSlackConversationId(channelId) {
+  if (!channelId) return void 0;
+  const trimmed = channelId.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.startsWith("slack:")) {
+    return trimmed;
+  }
+  const parts = trimmed.split(":");
+  return parts[1]?.trim() || void 0;
+}
+function getClient() {
+  if (client) return client;
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack canvas/list actions in this service",
+      "missing_token"
+    );
+  }
+  client = new WebClient(token);
+  return client;
+}
+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 === "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);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withSlackRetries(task, maxAttempts = 3, context = {}) {
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      return await task();
+    } catch (error) {
+      const mapped = mapSlackError(error);
+      const isRetryable = mapped.code === "rate_limited";
+      const baseLogAttributes = {
+        "app.slack.action": context.action ?? "unknown",
+        "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) {
+        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
+        },
+        "Retrying Slack action after transient failure"
+      );
+      const retryAfterMs = mapped.code === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
+      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
+      await sleep(retryAfterMs ?? backoffMs);
+    }
+  }
+  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 client2 = getClient();
+  const response = await withSlackRetries(
+    () => client2.files.info({
+      file: fileId
+    })
+  );
+  return response.file?.permalink;
+}
+async function downloadPrivateSlackFile(url) {
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack file downloads in this service",
+      "missing_token"
+    );
+  }
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Slack file download failed: ${response.status}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+// src/chat/destination.ts
+import { destinationSchema } from "@sentry/junior-plugin-api";
+
+// src/chat/slack/ids.ts
+function isSlackTeamId(value) {
+  return /^T[A-Z0-9]+$/.test(value);
+}
+function isSlackConversationId(value) {
+  return /^(C|G|D)[A-Z0-9]+$/.test(value);
+}
+
+// src/chat/destination.ts
+function createSlackDestination(input) {
+  const channelId = normalizeSlackConversationId(input.channelId);
+  const teamId = input.teamId?.trim();
+  if (!channelId || !teamId) {
+    return void 0;
+  }
+  if (!isSlackConversationId(channelId) || !isSlackTeamId(teamId)) {
+    return void 0;
+  }
+  return { platform: "slack", teamId, channelId };
+}
+function parseDestination(value) {
+  const parsed = destinationSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function sameDestination(left, right) {
+  return left.platform === right.platform && left.teamId === right.teamId && left.channelId === right.channelId;
+}
+function destinationKey(destination) {
+  return `slack:${destination.teamId}:${destination.channelId}`;
+}
+
+export {
+  SlackActionError,
+  getHeaderString,
+  normalizeSlackConversationId,
+  withSlackRetries,
+  getSlackClient,
+  isDmChannel,
+  isConversationScopedChannel,
+  isConversationChannel,
+  getFilePermalink,
+  downloadPrivateSlackFile,
+  createSlackDestination,
+  parseDestination,
+  sameDestination,
+  destinationKey
+};

package/dist/{chunk-PIVOJIUD.js → chunk-B5HKWWQB.js}

@@ -1,13 +1,17 @@
 import {
   SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter,
-  toOptionalTrimmed
-} from "./chunk-EBVQXCD2.js";
+  getStateAdapter
+} from "./chunk-R62YWUNO.js";
 import {
   getPluginRuntimeDependencies,
-  getPluginRuntimePostinstall,
+  getPluginRuntimePostinstall
+} from "./chunk-UXG6TU2U.js";
+import {
+  toOptionalTrimmed
+} from "./chunk-JS4HURDT.js";
+import {
   withSpan
-} from "./chunk-OIIXZOOC.js";
+} from "./chunk-BBXYXOJW.js";
 
 // src/chat/sandbox/runtime-dependency-snapshots.ts
 import { createHash } from "crypto";