@sentry/junior 0.1.0

package/dist/chunk-GDNDYMGX.js

@@ -0,0 +1,333 @@
+import {
+  logWarn
+} from "./chunk-BBOVH5RF.js";
+
+// src/chat/config.ts
+var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
+var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
+var DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS = 800;
+var TURN_TIMEOUT_BUFFER_SECONDS = 20;
+function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
+  const value = Number.parseInt(rawValue ?? "", 10);
+  if (Number.isNaN(value)) {
+    return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(DEFAULT_AGENT_TURN_TIMEOUT_MS, maxTimeoutMs));
+  }
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(value, maxTimeoutMs));
+}
+function resolveQueueCallbackMaxDurationSeconds() {
+  const value = Number.parseInt(process.env.QUEUE_CALLBACK_MAX_DURATION_SECONDS ?? "", 10);
+  if (Number.isNaN(value) || value <= 0) {
+    return DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS;
+  }
+  return value;
+}
+function resolveMaxTurnTimeoutMs(queueCallbackMaxDurationSeconds) {
+  const budgetSeconds = queueCallbackMaxDurationSeconds - TURN_TIMEOUT_BUFFER_SECONDS;
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, budgetSeconds * 1e3);
+}
+function buildBotConfig() {
+  const queueCallbackMaxDurationSeconds = resolveQueueCallbackMaxDurationSeconds();
+  const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(queueCallbackMaxDurationSeconds);
+  return {
+    userName: process.env.JUNIOR_BOT_NAME ?? "junior",
+    modelId: process.env.AI_MODEL ?? "anthropic/claude-sonnet-4.6",
+    fastModelId: process.env.AI_FAST_MODEL ?? process.env.AI_MODEL ?? "anthropic/claude-haiku-4.5",
+    turnTimeoutMs: parseAgentTurnTimeoutMs(process.env.AGENT_TURN_TIMEOUT_MS, maxTurnTimeoutMs)
+  };
+}
+var botConfig = buildBotConfig();
+function toOptionalTrimmed(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function getSlackBotToken() {
+  return toOptionalTrimmed(process.env.SLACK_BOT_TOKEN) ?? toOptionalTrimmed(process.env.SLACK_BOT_USER_TOKEN);
+}
+function getSlackSigningSecret() {
+  return toOptionalTrimmed(process.env.SLACK_SIGNING_SECRET);
+}
+function getSlackClientId() {
+  return toOptionalTrimmed(process.env.SLACK_CLIENT_ID);
+}
+function getSlackClientSecret() {
+  return toOptionalTrimmed(process.env.SLACK_CLIENT_SECRET);
+}
+function hasRedisConfig() {
+  return Boolean(process.env.REDIS_URL);
+}
+
+// src/chat/slack-actions/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 === "invalid_arguments") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_name") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "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());
+}
+
+export {
+  botConfig,
+  getSlackBotToken,
+  getSlackSigningSecret,
+  getSlackClientId,
+  getSlackClientSecret,
+  hasRedisConfig,
+  SlackActionError,
+  normalizeSlackConversationId,
+  withSlackRetries,
+  getSlackClient,
+  isDmChannel,
+  isConversationScopedChannel,
+  isConversationChannel,
+  getFilePermalink,
+  downloadPrivateSlackFile
+};

package/dist/chunk-MM3YNA4F.js

@@ -0,0 +1,203 @@
+import {
+  getSlackClient,
+  normalizeSlackConversationId,
+  withSlackRetries
+} from "./chunk-GDNDYMGX.js";
+
+// src/chat/slack-actions/channel.ts
+async function postMessageToChannel(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel message posting requires a valid channel ID");
+  }
+  const response = await withSlackRetries(
+    () => client.chat.postMessage({
+      channel: channelId,
+      text: input.text,
+      mrkdwn: true
+    }),
+    3,
+    { action: "chat.postMessage" }
+  );
+  if (!response.ts) {
+    throw new Error("Slack channel message posted without ts");
+  }
+  let permalink;
+  try {
+    const permalinkResponse = await withSlackRetries(
+      () => client.chat.getPermalink({
+        channel: channelId,
+        message_ts: response.ts
+      }),
+      3,
+      { action: "chat.getPermalink" }
+    );
+    permalink = permalinkResponse.permalink;
+  } catch {
+  }
+  return {
+    ts: response.ts,
+    permalink
+  };
+}
+async function addReactionToMessage(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack reaction requires a valid channel ID");
+  }
+  const timestamp = input.timestamp.trim();
+  if (!timestamp) {
+    throw new Error("Slack reaction requires a target message timestamp");
+  }
+  const emoji = input.emoji.trim().replaceAll(":", "");
+  if (!emoji) {
+    throw new Error("Slack reaction requires a non-empty emoji name");
+  }
+  await withSlackRetries(
+    () => client.reactions.add({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    }),
+    3,
+    { action: "reactions.add" }
+  );
+  return { ok: true };
+}
+async function removeReactionFromMessage(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack reaction requires a valid channel ID");
+  }
+  const timestamp = input.timestamp.trim();
+  if (!timestamp) {
+    throw new Error("Slack reaction requires a target message timestamp");
+  }
+  const emoji = input.emoji.trim().replaceAll(":", "");
+  if (!emoji) {
+    throw new Error("Slack reaction requires a non-empty emoji name");
+  }
+  await withSlackRetries(
+    () => client.reactions.remove({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    }),
+    3,
+    { action: "reactions.remove" }
+  );
+  return { ok: true };
+}
+async function listChannelMessages(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel history lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
+  const messages = [];
+  let cursor = input.cursor;
+  let pages = 0;
+  while (messages.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
+    const response = await withSlackRetries(
+      () => client.conversations.history({
+        channel: channelId,
+        limit: pageLimit,
+        cursor,
+        oldest: input.oldest,
+        latest: input.latest,
+        inclusive: input.inclusive
+      }),
+      3,
+      { action: "conversations.history" }
+    );
+    const batch = response.messages ?? [];
+    messages.push(...batch);
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor) {
+      break;
+    }
+  }
+  return {
+    messages: messages.slice(0, targetLimit),
+    nextCursor: cursor
+  };
+}
+async function listChannelMembers(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel member lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit, 200));
+  const response = await withSlackRetries(
+    () => client.conversations.members({
+      channel: channelId,
+      limit: targetLimit,
+      cursor: input.cursor
+    }),
+    3,
+    { action: "conversations.members" }
+  );
+  const members = (response.members ?? []).slice(0, targetLimit);
+  return {
+    members: members.map((userId) => ({ user_id: userId })),
+    nextCursor: response.response_metadata?.next_cursor || void 0
+  };
+}
+async function listThreadReplies(input) {
+  const client = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack thread reply lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit ?? 1e3, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 10, 10));
+  const pendingTargets = new Set(
+    (input.targetMessageTs ?? []).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  const replies = [];
+  let cursor;
+  let pages = 0;
+  while (replies.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - replies.length));
+    const response = await withSlackRetries(
+      () => client.conversations.replies({
+        channel: channelId,
+        ts: input.threadTs,
+        limit: pageLimit,
+        cursor
+      }),
+      3,
+      { action: "conversations.replies" }
+    );
+    const batch = response.messages ?? [];
+    replies.push(...batch);
+    for (const reply of batch) {
+      if (typeof reply.ts === "string" && pendingTargets.size > 0) {
+        pendingTargets.delete(reply.ts);
+      }
+    }
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor || pendingTargets.size === 0) {
+      break;
+    }
+  }
+  return replies.slice(0, targetLimit);
+}
+
+export {
+  postMessageToChannel,
+  addReactionToMessage,
+  removeReactionFromMessage,
+  listChannelMessages,
+  listChannelMembers,
+  listThreadReplies
+};

package/dist/chunk-OD6TOSY4.js

@@ -0,0 +1,95 @@
+import {
+  createRequestContext,
+  logException,
+  logWarn,
+  setSpanAttributes,
+  setSpanStatus,
+  withContext,
+  withSpan
+} from "./chunk-BBOVH5RF.js";
+
+// src/handlers/webhooks.ts
+import { after } from "next/server";
+import * as Sentry from "@sentry/nextjs";
+async function loadBot() {
+  const { bot } = await import("./bot-DLML4Z7F.js");
+  return bot;
+}
+async function POST(request, context) {
+  const bot = await loadBot();
+  const { platform } = await context.params;
+  const handler = bot.webhooks[platform];
+  const requestContext = createRequestContext(request, { platform });
+  const requestUrl = new URL(request.url);
+  return withContext(requestContext, async () => {
+    if (!handler) {
+      const error = new Error(`Unknown platform: ${platform}`);
+      logException(error, "webhook_platform_unknown", {}, {
+        "http.response.status_code": 404
+      }, `Unknown platform: ${platform}`);
+      return new Response(`Unknown platform: ${platform}`, { status: 404 });
+    }
+    try {
+      return await withSpan(
+        "http.server.request",
+        "http.server",
+        requestContext,
+        async () => {
+          try {
+            const activeSpan = Sentry.getActiveSpan();
+            const response = await handler(request, {
+              waitUntil: (task) => after(() => {
+                const runTask = () => {
+                  const taskOrFactory = task;
+                  return typeof taskOrFactory === "function" ? taskOrFactory() : taskOrFactory;
+                };
+                if (activeSpan) {
+                  return Sentry.withActiveSpan(activeSpan, runTask);
+                }
+                return runTask();
+              })
+            });
+            if (response.status >= 400) {
+              let responseBodySnippet;
+              try {
+                responseBodySnippet = (await response.clone().text()).slice(0, 300);
+              } catch {
+                responseBodySnippet = void 0;
+              }
+              logWarn(
+                "webhook_non_success_response",
+                {},
+                {
+                  "http.response.status_code": response.status,
+                  "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
+                  "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
+                  ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
+                },
+                `Webhook ${platform} returned ${response.status}`
+              );
+            }
+            setSpanAttributes({
+              "http.response.status_code": response.status
+            });
+            setSpanStatus(response.status >= 500 ? "error" : "ok");
+            return response;
+          } catch (error) {
+            setSpanStatus("error");
+            throw error;
+          }
+        },
+        {
+          "http.request.method": request.method,
+          "url.path": requestUrl.pathname
+        }
+      );
+    } catch (error) {
+      logException(error, "webhook_handler_failed");
+      throw error;
+    }
+  });
+}
+
+export {
+  POST
+};

package/dist/chunk-ZA2IDPVG.js

@@ -0,0 +1,39 @@
+// src/chat/queue/client.ts
+import { handleCallback, send } from "@vercel/queue";
+var DEFAULT_TOPIC_NAME = "junior-thread-message";
+var MAX_DELIVERY_ATTEMPTS = 10;
+function getThreadMessageTopic() {
+  return DEFAULT_TOPIC_NAME;
+}
+async function enqueueThreadMessage(payload, options) {
+  const result = await send(getThreadMessageTopic(), payload, {
+    ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+  });
+  return result.messageId ?? void 0;
+}
+function createQueueCallbackHandler(handler) {
+  return handleCallback(
+    async (message, metadata) => {
+      await handler(message, {
+        messageId: metadata.messageId,
+        deliveryCount: metadata.deliveryCount,
+        topicName: metadata.topicName
+      });
+    },
+    {
+      retry: (_error, metadata) => {
+        if (metadata.deliveryCount >= MAX_DELIVERY_ATTEMPTS) {
+          return { acknowledge: true };
+        }
+        const backoffSeconds = Math.min(300, Math.max(5, metadata.deliveryCount * 5));
+        return { afterSeconds: backoffSeconds };
+      }
+    }
+  );
+}
+
+export {
+  getThreadMessageTopic,
+  enqueueThreadMessage,
+  createQueueCallbackHandler
+};