@sentry/junior 0.9.3 → 0.10.0

package/dist/chunk-XHISVOAJ.js

@@ -1,678 +0,0 @@
-import {
-  DeferredThreadMessageError,
-  buildDeterministicTurnId,
-  coerceThreadConversationState,
-  createQueueCallbackHandler,
-  downloadPrivateSlackFile,
-  getThreadMessageTopic,
-  removeReactionFromMessage,
-  slackRuntime
-} from "./chunk-LWHXDHIN.js";
-import {
-  getConnectedStateContext,
-  getStateAdapter
-} from "./chunk-HRA2FXYH.js";
-import {
-  createRequestContext,
-  logError,
-  logException,
-  logInfo,
-  logWarn,
-  setSpanStatus,
-  withContext,
-  withSpan
-} from "./chunk-ZW4OVKF5.js";
-
-// src/chat/queue/process-thread-message.ts
-import { Message, ThreadImpl } from "chat";
-
-// src/chat/state/queue-processing-store.ts
-var QUEUE_MESSAGE_PROCESSING_PREFIX = "junior:queue_message";
-var QUEUE_MESSAGE_PROCESSING_TTL_MS = 30 * 60 * 1e3;
-var QUEUE_MESSAGE_COMPLETED_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var QUEUE_MESSAGE_FAILED_TTL_MS = 6 * 60 * 60 * 1e3;
-var CLAIM_OR_RECLAIM_PROCESSING_SCRIPT = `
-  local key = KEYS[1]
-  local nowMs = tonumber(ARGV[1])
-  local ttlMs = tonumber(ARGV[2])
-  local payload = ARGV[3]
-  local current = redis.call("get", key)
-
-  if not current then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 1
-  end
-
-  local ok, parsed = pcall(cjson.decode, current)
-  if not ok or type(parsed) ~= "table" then
-    return 0
-  end
-
-  local status = parsed["status"]
-  if status == "failed" then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 3
-  end
-  if status ~= "processing" then
-    return 0
-  end
-
-  local updatedAtMs = tonumber(parsed["updatedAtMs"])
-  if not updatedAtMs then
-    return 0
-  end
-
-  if updatedAtMs + ttlMs < nowMs then
-    redis.call("set", key, payload, "PX", ttlMs)
-    return 2
-  end
-
-  return 0
-`;
-var UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT = `
-  local key = KEYS[1]
-  local ownerToken = ARGV[1]
-  local ttlMs = tonumber(ARGV[2])
-  local payload = ARGV[3]
-  local current = redis.call("get", key)
-
-  if not current then
-    return 0
-  end
-
-  local ok, parsed = pcall(cjson.decode, current)
-  if not ok or type(parsed) ~= "table" then
-    return 0
-  end
-
-  local currentOwner = parsed["ownerToken"]
-  local status = parsed["status"]
-  if currentOwner ~= ownerToken then
-    return 0
-  end
-  if status ~= "processing" then
-    return 0
-  end
-
-  redis.call("set", key, payload, "PX", ttlMs)
-  return 1
-`;
-function queueMessageKey(rawKey) {
-  return `${QUEUE_MESSAGE_PROCESSING_PREFIX}:${rawKey}`;
-}
-function buildQueueMessageProcessingPayload(args) {
-  return JSON.stringify({
-    status: args.status,
-    updatedAtMs: args.updatedAtMs ?? Date.now(),
-    ownerToken: args.ownerToken,
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-}
-function parseQueueMessageState(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!parsed || parsed.status !== "processing" && parsed.status !== "completed" && parsed.status !== "failed" || typeof parsed.updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      status: parsed.status,
-      updatedAtMs: parsed.updatedAtMs,
-      ...typeof parsed.ownerToken === "string" ? { ownerToken: parsed.ownerToken } : {},
-      ...typeof parsed.queueMessageId === "string" ? { queueMessageId: parsed.queueMessageId } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function updateQueueMessageProcessingStateIfOwner(args) {
-  const existingState = parseQueueMessageState(
-    await args.stateAdapter.get(queueMessageKey(args.rawKey))
-  );
-  if (!existingState || existingState.status !== "processing" || existingState.ownerToken !== args.ownerToken) {
-    return false;
-  }
-  await args.stateAdapter.set(
-    queueMessageKey(args.rawKey),
-    args.payload,
-    args.ttlMs
-  );
-  return true;
-}
-async function getQueueMessageProcessingState(rawKey) {
-  const adapter = getStateAdapter();
-  await adapter.connect();
-  const state = await adapter.get(queueMessageKey(rawKey));
-  return parseQueueMessageState(state);
-}
-async function acquireQueueMessageProcessingOwnership(args) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const key = queueMessageKey(args.rawKey);
-  const nowMs = Date.now();
-  const payload = buildQueueMessageProcessingPayload({
-    ownerToken: args.ownerToken,
-    queueMessageId: args.queueMessageId,
-    status: "processing",
-    updatedAtMs: nowMs
-  });
-  if (redisStateAdapter) {
-    const result = await redisStateAdapter.getClient().eval(CLAIM_OR_RECLAIM_PROCESSING_SCRIPT, {
-      keys: [key],
-      arguments: [
-        String(nowMs),
-        String(QUEUE_MESSAGE_PROCESSING_TTL_MS),
-        payload
-      ]
-    });
-    if (result === 1) {
-      return "acquired";
-    }
-    if (result === 2) {
-      return "reclaimed";
-    }
-    if (result === 3) {
-      return "recovered";
-    }
-    return "blocked";
-  }
-  const existingState = parseQueueMessageState(await stateAdapter.get(key));
-  if (!existingState) {
-    const claimed = await stateAdapter.setIfNotExists(
-      key,
-      payload,
-      QUEUE_MESSAGE_PROCESSING_TTL_MS
-    );
-    return claimed ? "acquired" : "blocked";
-  }
-  if (existingState.status === "failed") {
-    await stateAdapter.set(key, payload, QUEUE_MESSAGE_PROCESSING_TTL_MS);
-    return "recovered";
-  }
-  if (existingState.status === "processing" && existingState.updatedAtMs + QUEUE_MESSAGE_PROCESSING_TTL_MS < nowMs) {
-    await stateAdapter.set(key, payload, QUEUE_MESSAGE_PROCESSING_TTL_MS);
-    return "reclaimed";
-  }
-  return "blocked";
-}
-async function refreshQueueMessageProcessingOwnership(args) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const payload = buildQueueMessageProcessingPayload({
-    ownerToken: args.ownerToken,
-    queueMessageId: args.queueMessageId,
-    status: "processing"
-  });
-  if (redisStateAdapter) {
-    const result = await redisStateAdapter.getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-      keys: [queueMessageKey(args.rawKey)],
-      arguments: [
-        args.ownerToken,
-        String(QUEUE_MESSAGE_PROCESSING_TTL_MS),
-        payload
-      ]
-    });
-    return result === 1;
-  }
-  return await updateQueueMessageProcessingStateIfOwner({
-    rawKey: args.rawKey,
-    ownerToken: args.ownerToken,
-    payload,
-    ttlMs: QUEUE_MESSAGE_PROCESSING_TTL_MS,
-    stateAdapter
-  });
-}
-async function completeQueueMessageProcessingOwnership(args) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const payload = buildQueueMessageProcessingPayload({
-    ownerToken: args.ownerToken,
-    queueMessageId: args.queueMessageId,
-    status: "completed"
-  });
-  if (redisStateAdapter) {
-    const result = await redisStateAdapter.getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-      keys: [queueMessageKey(args.rawKey)],
-      arguments: [
-        args.ownerToken,
-        String(QUEUE_MESSAGE_COMPLETED_TTL_MS),
-        payload
-      ]
-    });
-    return result === 1;
-  }
-  return await updateQueueMessageProcessingStateIfOwner({
-    rawKey: args.rawKey,
-    ownerToken: args.ownerToken,
-    payload,
-    ttlMs: QUEUE_MESSAGE_COMPLETED_TTL_MS,
-    stateAdapter
-  });
-}
-async function failQueueMessageProcessingOwnership(args) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const payload = buildQueueMessageProcessingPayload({
-    errorMessage: args.errorMessage,
-    ownerToken: args.ownerToken,
-    queueMessageId: args.queueMessageId,
-    status: "failed"
-  });
-  if (redisStateAdapter) {
-    const result = await redisStateAdapter.getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
-      keys: [queueMessageKey(args.rawKey)],
-      arguments: [
-        args.ownerToken,
-        String(QUEUE_MESSAGE_FAILED_TTL_MS),
-        payload
-      ]
-    });
-    return result === 1;
-  }
-  return await updateQueueMessageProcessingStateIfOwner({
-    rawKey: args.rawKey,
-    ownerToken: args.ownerToken,
-    payload,
-    ttlMs: QUEUE_MESSAGE_FAILED_TTL_MS,
-    stateAdapter
-  });
-}
-
-// src/chat/queue/process-thread-message.ts
-var THREAD_PROCESSING_LOCK_TTL_MS = 5 * 60 * 1e3;
-var THREAD_PROCESSING_LOCK_HEARTBEAT_MS = 60 * 1e3;
-function isSerializedThread(thread) {
-  return typeof thread === "object" && thread !== null && thread._type === "chat:Thread";
-}
-function isSerializedMessage(message) {
-  return typeof message === "object" && message !== null && message._type === "chat:Message";
-}
-function getPayloadChannelId(payload) {
-  return payload.thread.channelId;
-}
-function getPayloadUserId(payload) {
-  return payload.message.author?.userId;
-}
-function createMessageOwnerToken() {
-  return `msg-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-}
-var QueueMessageOwnershipError = class extends Error {
-  constructor(stage, dedupKey) {
-    super(
-      `Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`
-    );
-    this.name = "QueueMessageOwnershipError";
-  }
-};
-var defaultProcessQueuedThreadMessageDeps = {
-  clearProcessingReaction: async ({
-    channelId,
-    timestamp
-  }) => {
-    await removeReactionFromMessage({
-      channelId,
-      timestamp,
-      emoji: "eyes"
-    });
-  },
-  logInfo,
-  logWarn
-};
-function resolveDeps(deps) {
-  return {
-    ...defaultProcessQueuedThreadMessageDeps,
-    ...deps
-  };
-}
-function deserializeThread(thread) {
-  if (isSerializedThread(thread)) {
-    return ThreadImpl.fromJSON(thread);
-  }
-  return thread;
-}
-function deserializeMessage(message) {
-  if (isSerializedMessage(message)) {
-    return Message.fromJSON(message);
-  }
-  return message;
-}
-async function logThreadMessageFailure(payload, errorMessage) {
-  logError(
-    "queue_message_failed",
-    {
-      slackThreadId: payload.normalizedThreadId,
-      slackChannelId: getPayloadChannelId(payload),
-      slackUserId: getPayloadUserId(payload)
-    },
-    {
-      "messaging.message.id": payload.message.id,
-      "app.queue.message_kind": payload.kind,
-      "app.queue.message_id": payload.queueMessageId,
-      "error.message": errorMessage
-    },
-    "Queue message processing failed"
-  );
-}
-async function processQueuedThreadMessage(payload, deps) {
-  const resolvedDeps = resolveDeps(deps);
-  const existingMessageState = await getQueueMessageProcessingState(
-    payload.dedupKey
-  );
-  if (existingMessageState?.status === "completed") {
-    resolvedDeps.logInfo(
-      "queue_message_skipped_completed",
-      {
-        slackThreadId: payload.normalizedThreadId,
-        slackChannelId: getPayloadChannelId(payload),
-        slackUserId: getPayloadUserId(payload)
-      },
-      {
-        "messaging.message.id": payload.message.id,
-        "app.queue.message_kind": payload.kind,
-        "app.queue.message_id": payload.queueMessageId,
-        "app.queue.processing_state": existingMessageState.status
-      },
-      "Skipping queue message because it is already completed"
-    );
-    return;
-  }
-  const state = getStateAdapter();
-  await state.connect();
-  const threadLock = await state.acquireLock(
-    payload.normalizedThreadId,
-    THREAD_PROCESSING_LOCK_TTL_MS
-  );
-  if (!threadLock) {
-    resolvedDeps.logInfo(
-      "queue_message_deferred_thread_locked",
-      {
-        slackThreadId: payload.normalizedThreadId,
-        slackChannelId: getPayloadChannelId(payload),
-        slackUserId: getPayloadUserId(payload)
-      },
-      {
-        "messaging.message.id": payload.message.id,
-        "app.queue.message_kind": payload.kind,
-        "app.queue.message_id": payload.queueMessageId
-      },
-      "Deferring queue message because another turn already owns the thread lock"
-    );
-    throw new DeferredThreadMessageError(
-      "thread_locked",
-      payload.normalizedThreadId
-    );
-  }
-  const threadLockHeartbeat = startThreadLockHeartbeat({
-    lock: threadLock,
-    state,
-    payload,
-    logWarn: resolvedDeps.logWarn
-  });
-  try {
-    const runtimePayload = {
-      ...payload,
-      thread: deserializeThread(payload.thread),
-      message: deserializeMessage(payload.message)
-    };
-    const currentTurnId = buildDeterministicTurnId(runtimePayload.message.id);
-    const activeTurnId = coerceThreadConversationState(
-      await runtimePayload.thread.state
-    ).processing.activeTurnId;
-    if (activeTurnId && activeTurnId !== currentTurnId) {
-      resolvedDeps.logInfo(
-        "queue_message_deferred_active_turn",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: getPayloadChannelId(payload),
-          slackUserId: getPayloadUserId(payload)
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.thread.active_turn_id": activeTurnId,
-          "app.thread.current_turn_id": currentTurnId
-        },
-        "Deferring queue message because another turn is still active for the thread"
-      );
-      throw new DeferredThreadMessageError(
-        "active_turn",
-        payload.normalizedThreadId,
-        {
-          activeTurnId,
-          currentTurnId
-        }
-      );
-    }
-    const ownerToken = createMessageOwnerToken();
-    const claimResult = await acquireQueueMessageProcessingOwnership({
-      rawKey: payload.dedupKey,
-      ownerToken,
-      queueMessageId: payload.queueMessageId
-    });
-    if (claimResult === "blocked") {
-      resolvedDeps.logInfo(
-        "queue_message_skipped_blocked",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: getPayloadChannelId(payload),
-          slackUserId: getPayloadUserId(payload)
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.queue.claim_result": claimResult,
-          "app.queue.processing_state": "processing"
-        },
-        "Skipping queue message because another worker owns it"
-      );
-      return;
-    }
-    let reactionCleared = false;
-    const clearProcessingReaction = async () => {
-      if (reactionCleared) {
-        return;
-      }
-      reactionCleared = true;
-      try {
-        await resolvedDeps.clearProcessingReaction({
-          channelId: runtimePayload.thread.channelId,
-          timestamp: runtimePayload.message.id
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        resolvedDeps.logWarn(
-          "queue_processing_reaction_clear_failed",
-          {
-            slackThreadId: payload.normalizedThreadId,
-            slackChannelId: getPayloadChannelId(payload),
-            slackUserId: getPayloadUserId(payload)
-          },
-          {
-            "messaging.message.id": payload.message.id,
-            "app.queue.message_kind": payload.kind,
-            "app.queue.message_id": payload.queueMessageId,
-            "error.message": errorMessage
-          },
-          "Failed to remove processing reaction after queue turn completion"
-        );
-      }
-    };
-    try {
-      const refreshed = await refreshQueueMessageProcessingOwnership({
-        rawKey: payload.dedupKey,
-        ownerToken,
-        queueMessageId: payload.queueMessageId
-      });
-      if (!refreshed) {
-        throw new QueueMessageOwnershipError("refresh", payload.dedupKey);
-      }
-      await resolvedDeps.dispatch({
-        kind: runtimePayload.kind,
-        thread: runtimePayload.thread,
-        message: runtimePayload.message
-      });
-      await clearProcessingReaction();
-      const completed = await completeQueueMessageProcessingOwnership({
-        rawKey: payload.dedupKey,
-        ownerToken,
-        queueMessageId: payload.queueMessageId
-      });
-      if (!completed) {
-        throw new QueueMessageOwnershipError("complete", payload.dedupKey);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await clearProcessingReaction();
-      await logThreadMessageFailure(payload, errorMessage);
-      const failed = await failQueueMessageProcessingOwnership({
-        rawKey: payload.dedupKey,
-        ownerToken,
-        errorMessage,
-        queueMessageId: payload.queueMessageId
-      });
-      if (!failed && !(error instanceof QueueMessageOwnershipError)) {
-        throw new Error(
-          `Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`
-        );
-      }
-      throw error;
-    }
-  } finally {
-    await threadLockHeartbeat.stop();
-  }
-}
-function startThreadLockHeartbeat(args) {
-  const interval = setInterval(() => {
-    void args.state.extendLock(args.lock, THREAD_PROCESSING_LOCK_TTL_MS).catch((error) => {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      args.logWarn(
-        "queue_thread_lock_extend_failed",
-        {
-          slackThreadId: args.payload.normalizedThreadId,
-          slackChannelId: getPayloadChannelId(args.payload),
-          slackUserId: getPayloadUserId(args.payload)
-        },
-        {
-          "messaging.message.id": args.payload.message.id,
-          "app.queue.message_kind": args.payload.kind,
-          "app.queue.message_id": args.payload.queueMessageId,
-          "error.message": errorMessage
-        },
-        "Failed to extend thread-processing lock during queue execution"
-      );
-    });
-  }, THREAD_PROCESSING_LOCK_HEARTBEAT_MS);
-  interval.unref?.();
-  return {
-    stop: async () => {
-      clearInterval(interval);
-      await args.state.releaseLock(args.lock);
-    }
-  };
-}
-
-// src/chat/queue/thread-message-dispatcher.ts
-function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2) {
-  for (const attachment of message.attachments) {
-    if (!attachment.fetchData && attachment.url) {
-      attachment.fetchData = () => downloadPrivateSlackFile2(attachment.url);
-    }
-  }
-}
-function createThreadMessageDispatcher(options) {
-  const downloadPrivateSlackFile2 = options.downloadPrivateSlackFile ?? downloadPrivateSlackFile;
-  return async function dispatch2(args) {
-    rehydrateAttachmentFetchers(args.message, downloadPrivateSlackFile2);
-    if (args.kind === "new_mention") {
-      await options.runtime.handleNewMention(args.thread, args.message, {
-        beforeFirstResponsePost: args.beforeFirstResponsePost
-      });
-      return;
-    }
-    await options.runtime.handleSubscribedMessage(args.thread, args.message, {
-      beforeFirstResponsePost: args.beforeFirstResponsePost
-    });
-  };
-}
-
-// src/handlers/queue-callback.ts
-var dispatch = createThreadMessageDispatcher({
-  runtime: slackRuntime
-});
-var callbackHandler = createQueueCallbackHandler(
-  async (message, metadata) => {
-    if (metadata.topicName === getThreadMessageTopic()) {
-      const payload = {
-        ...message,
-        queueMessageId: metadata.messageId
-      };
-      logInfo(
-        "queue_callback_received",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: payload.thread.channelId,
-          slackUserId: payload.message.author?.userId
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.queue.delivery_count": metadata.deliveryCount,
-          "app.queue.topic": metadata.topicName
-        },
-        "Received queue callback payload"
-      );
-      await withSpan(
-        "queue.process_message",
-        "queue.process_message",
-        {
-          slackThreadId: payload.normalizedThreadId,
-          slackChannelId: payload.thread.channelId,
-          slackUserId: payload.message.author?.userId
-        },
-        async () => {
-          await processQueuedThreadMessage(payload, {
-            dispatch
-          });
-        },
-        {
-          "messaging.message.id": payload.message.id,
-          "app.queue.message_kind": payload.kind,
-          "app.queue.message_id": payload.queueMessageId,
-          "app.queue.delivery_count": metadata.deliveryCount,
-          "app.queue.topic": metadata.topicName
-        }
-      );
-      return;
-    }
-    throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
-  }
-);
-async function POST(request) {
-  const requestContext = createRequestContext(request, { platform: "queue" });
-  return withContext(requestContext, async () => {
-    try {
-      const response = await callbackHandler(request);
-      setSpanStatus(response.status >= 500 ? "error" : "ok");
-      return response;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logError(
-        "queue_callback_failed",
-        {},
-        {
-          "error.message": message
-        },
-        "Queue callback processing failed"
-      );
-      logException(error, "queue_callback_failed");
-      throw error;
-    }
-  });
-}
-
-export {
-  POST
-};