@sentry/junior 0.93.0 → 0.95.0

package/dist/{chunk-G3E7SCME.js → chunk-CZEX6KIQ.js}

@@ -1,3 +1,25 @@
+// 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 });
+  });
+}
+
 // src/chat/sandbox/paths.ts
 function normalizeWorkspaceRoot(input) {
   const candidate = (input ?? "").trim();
@@ -20,6 +42,7 @@ function sandboxSkillFile(skillName) {
 }
 
 export {
+  sleep,
   SANDBOX_WORKSPACE_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_DATA_ROOT,

package/dist/{chunk-TNUUATT7.js → chunk-E3E2XNCN.js}

@@ -1,11 +1,11 @@
 import {
   getStateAdapter
-} from "./chunk-7STN2ZSK.js";
+} from "./chunk-GUE7HTNR.js";
 import {
   logException,
   logInfo,
   logWarn
-} from "./chunk-S6QKIGRM.js";
+} from "./chunk-WPOJ443W.js";
 
 // src/chat/plugins/logging.ts
 function createPluginLogger(plugin) {

package/dist/{chunk-LNCREA5Z.js → chunk-EKNJM5IG.js}

@@ -1,19 +1,9 @@
 import {
   normalizeSlackConversationId
-} from "./chunk-UUB3D2XI.js";
-import {
-  getStateAdapter
-} from "./chunk-7STN2ZSK.js";
+} from "./chunk-NSCHU54X.js";
 import {
   parseSlackThreadId
-} from "./chunk-YYBX2BD5.js";
-import {
-  parseStoredSlackActor
-} from "./chunk-S6QKIGRM.js";
-import {
-  isRecord,
-  toOptionalNumber
-} from "./chunk-OB42YVAE.js";
+} from "./chunk-GY34VGP5.js";
 import {
   getClient
 } from "./chunk-3DA7X2U3.js";
@@ -164,116 +154,6 @@ function formatSlackConversationRedactedLabel(context) {
   return formatSlackConversationTypeLabel(context.type);
 }
 
-// src/chat/state/conversation-details.ts
-import { THREAD_STATE_TTL_MS } from "chat";
-var CONVERSATION_PREFIX = "junior:conversation";
-var CONVERSATION_DETAILS_TTL_MS = THREAD_STATE_TTL_MS;
-function conversationContextKey(conversationId) {
-  return `${CONVERSATION_PREFIX}:${conversationId}:context`;
-}
-function conversationTitleKey(conversationId) {
-  return `${CONVERSATION_PREFIX}:${conversationId}:title`;
-}
-function parseOriginActor(value) {
-  return parseStoredSlackActor(value);
-}
-function parseOriginSurface(value) {
-  if (value === "slack" || value === "api" || value === "scheduler" || value === "internal") {
-    return value;
-  }
-  return void 0;
-}
-function storedContextFromInput(context) {
-  return {
-    ...context.channelName ? { channelName: context.channelName } : {},
-    ...context.originSurface ? { originSurface: context.originSurface } : {},
-    ...context.originActor ? { originActor: context.originActor } : {},
-    startedAtMs: context.startedAtMs
-  };
-}
-function parseContext(value) {
-  if (!isRecord(value)) return void 0;
-  const startedAtMs = toOptionalNumber(value.startedAtMs);
-  if (startedAtMs === void 0) return void 0;
-  return {
-    ...typeof value.channelName === "string" && value.channelName.trim() ? { channelName: value.channelName.trim() } : {},
-    ...parseOriginSurface(value.originSurface) ? { originSurface: parseOriginSurface(value.originSurface) } : {},
-    ...parseOriginActor(value.originActor) ? { originActor: parseOriginActor(value.originActor) } : {},
-    startedAtMs
-  };
-}
-function parseTitle(value) {
-  if (!isRecord(value)) return void 0;
-  const displayTitle = typeof value.displayTitle === "string" && value.displayTitle.trim() ? value.displayTitle.trim() : void 0;
-  if (!displayTitle) return void 0;
-  return {
-    displayTitle,
-    ...typeof value.titleSourceMessageId === "string" ? { titleSourceMessageId: value.titleSourceMessageId } : {}
-  };
-}
-async function initConversationContext(conversationId, context) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const key = conversationContextKey(conversationId);
-  const inserted = await stateAdapter.setIfNotExists(
-    key,
-    storedContextFromInput(context),
-    CONVERSATION_DETAILS_TTL_MS
-  );
-  if (inserted) return;
-  const existing = parseContext(await stateAdapter.get(key));
-  if (!existing) {
-    return;
-  }
-  await stateAdapter.set(key, existing, CONVERSATION_DETAILS_TTL_MS);
-}
-async function setConversationTitle(conversationId, title) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  await stateAdapter.set(
-    conversationTitleKey(conversationId),
-    {
-      displayTitle: title.displayTitle,
-      ...title.titleSourceMessageId ? { titleSourceMessageId: title.titleSourceMessageId } : {}
-    },
-    CONVERSATION_DETAILS_TTL_MS
-  );
-}
-async function getConversationDetails(conversationId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const [rawContext, rawTitle] = await Promise.all([
-    stateAdapter.get(conversationContextKey(conversationId)),
-    stateAdapter.get(conversationTitleKey(conversationId))
-  ]);
-  const context = parseContext(rawContext);
-  const title = parseTitle(rawTitle);
-  if (!context && !title) return void 0;
-  return {
-    conversationId,
-    ...title?.displayTitle ? { displayTitle: title.displayTitle } : {},
-    ...title?.titleSourceMessageId ? { titleSourceMessageId: title.titleSourceMessageId } : {},
-    ...context?.channelName ? { channelName: context.channelName } : {},
-    ...context?.originSurface ? { originSurface: context.originSurface } : {},
-    ...context?.originActor ? { originActor: context.originActor } : {},
-    ...context?.startedAtMs !== void 0 ? { startedAtMs: context.startedAtMs } : {}
-  };
-}
-async function getConversationDetailsForIds(conversationIds) {
-  const uniqueIds = [...new Set(conversationIds)].filter(Boolean);
-  const entries = await Promise.all(
-    uniqueIds.map(async (id) => {
-      const details = await getConversationDetails(id);
-      return details ? [id, details] : void 0;
-    })
-  );
-  const result = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (entry) result.set(entry[0], entry[1]);
-  }
-  return result;
-}
-
 export {
   GET,
   buildSentryConversationUrl,
@@ -282,9 +162,5 @@ export {
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   resolveSlackConversationContextFromThreadId,
-  formatSlackConversationRedactedLabel,
-  initConversationContext,
-  setConversationTitle,
-  getConversationDetails,
-  getConversationDetailsForIds
+  formatSlackConversationRedactedLabel
 };

package/dist/{chunk-NAPITCZ6.js → chunk-GUE7HTNR.js}

@@ -6,7 +6,7 @@ import {
   toGenAiMessageMetadata,
   toGenAiMessagesTraceAttributes,
   toGenAiTextMetadata
-} from "./chunk-YYBX2BD5.js";
+} from "./chunk-GY34VGP5.js";
 import {
   extractGenAiUsageAttributes,
   logException,
@@ -14,12 +14,15 @@ import {
   serializeGenAiAttribute,
   setSpanAttributes,
   withSpan
-} from "./chunk-S6QKIGRM.js";
+} from "./chunk-WPOJ443W.js";
 
 // src/chat/xml.ts
 function escapeXml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
+function unescapeXml(value) {
+  return value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
+}
 
 // src/chat/current-instruction.ts
 var CURRENT_INSTRUCTION_TAG = "current-instruction";
@@ -28,9 +31,6 @@ var CURRENT_INSTRUCTION_OPEN_BARE = `<${CURRENT_INSTRUCTION_TAG}>`;
 var CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX = `<${CURRENT_INSTRUCTION_TAG} `;
 var CURRENT_INSTRUCTION_CLOSE = `
 </${CURRENT_INSTRUCTION_TAG}>`;
-function unescapeXml(value) {
-  return value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&gt;", ">").replaceAll("&lt;", "<").replaceAll("&amp;", "&");
-}
 function isCurrentInstructionOpeningTag(value) {
   return value === CURRENT_INSTRUCTION_OPEN_BARE || value.startsWith(CURRENT_INSTRUCTION_OPEN_ATTR_PREFIX) && value.endsWith(">");
 }
@@ -795,9 +795,249 @@ function setSlackReactionConfig(overrides) {
   }
 }
 
+// src/chat/state/adapter.ts
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { createRedisState } from "@chat-adapter/state-redis";
+
+// src/chat/state/locks.ts
+var ACTIVE_LOCK_TTL_MS = 9e4;
+async function acquireActiveLock(state, threadId) {
+  return await state.acquireLock(threadId, ACTIVE_LOCK_TTL_MS);
+}
+
+// src/chat/state/adapter.ts
+var ACTIVE_LOCK_HEARTBEAT_MS = 3e4;
+var stateAdapter;
+var redisStateAdapter;
+function createPrefixedStateAdapter(base, prefix) {
+  const prefixed = (value) => `${prefix}:${value}`;
+  const unprefixed = (value) => value.startsWith(`${prefix}:`) ? value.slice(prefix.length + 1) : value;
+  const prefixLock = (lock) => ({
+    ...lock,
+    threadId: prefixed(lock.threadId)
+  });
+  const unprefixLock = (lock) => ({
+    ...lock,
+    threadId: unprefixed(lock.threadId)
+  });
+  return {
+    appendToList: (key, value, options) => base.appendToList(prefixed(key), value, options),
+    connect: () => base.connect(),
+    disconnect: () => base.disconnect(),
+    subscribe: (threadId) => base.subscribe(prefixed(threadId)),
+    unsubscribe: (threadId) => base.unsubscribe(prefixed(threadId)),
+    isSubscribed: (threadId) => base.isSubscribed(prefixed(threadId)),
+    acquireLock: async (threadId, ttlMs) => {
+      const lock = await base.acquireLock(prefixed(threadId), ttlMs);
+      return lock ? unprefixLock(lock) : null;
+    },
+    releaseLock: (lock) => base.releaseLock(prefixLock(lock)),
+    extendLock: async (lock, ttlMs) => {
+      const prefixedLock = prefixLock(lock);
+      const extended = await base.extendLock(prefixedLock, ttlMs);
+      if (extended) {
+        lock.expiresAt = prefixedLock.expiresAt;
+      }
+      return extended;
+    },
+    forceReleaseLock: (threadId) => base.forceReleaseLock(prefixed(threadId)),
+    enqueue: (threadId, entry, maxSize) => base.enqueue(prefixed(threadId), entry, maxSize),
+    dequeue: (threadId) => base.dequeue(prefixed(threadId)),
+    queueDepth: (threadId) => base.queueDepth(prefixed(threadId)),
+    get: (key) => base.get(prefixed(key)),
+    getList: (key) => base.getList(prefixed(key)),
+    set: (key, value, ttlMs) => base.set(prefixed(key), value, ttlMs),
+    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(prefixed(key), value, ttlMs),
+    delete: (key) => base.delete(prefixed(key))
+  };
+}
+function createQueuedStateAdapter(base, options) {
+  const heartbeats = /* @__PURE__ */ new Map();
+  const shouldHeartbeatLock = (ttlMs) => ttlMs === ACTIVE_LOCK_TTL_MS;
+  const heartbeatKey = (lock) => `${lock.threadId}:${lock.token}`;
+  const stopHeartbeatByKey = (key) => {
+    const heartbeat = heartbeats.get(key);
+    if (!heartbeat) {
+      return;
+    }
+    clearInterval(heartbeat.timer);
+    heartbeats.delete(key);
+  };
+  const stopHeartbeat = (lock) => {
+    stopHeartbeatByKey(heartbeatKey(lock));
+  };
+  const stopHeartbeatsForThread = (threadId) => {
+    for (const [key, heartbeat] of heartbeats) {
+      if (heartbeat.lock.threadId === threadId) {
+        stopHeartbeatByKey(key);
+      }
+    }
+  };
+  const stopAllHeartbeats = () => {
+    for (const key of heartbeats.keys()) {
+      stopHeartbeatByKey(key);
+    }
+  };
+  const runHeartbeat = async (key) => {
+    const heartbeat = heartbeats.get(key);
+    if (!heartbeat || heartbeat.inFlight) {
+      return;
+    }
+    heartbeat.inFlight = true;
+    try {
+      if (Date.now() - heartbeat.startedAtMs >= options.activeLockMaxAgeMs) {
+        stopHeartbeatByKey(key);
+        return;
+      }
+      const extended = await base.extendLock(heartbeat.lock, heartbeat.ttlMs);
+      if (!extended) {
+        stopHeartbeatByKey(key);
+        return;
+      }
+      heartbeat.lock.expiresAt = Date.now() + heartbeat.ttlMs;
+    } catch {
+    } finally {
+      const current = heartbeats.get(key);
+      if (current === heartbeat) {
+        current.inFlight = false;
+      }
+    }
+  };
+  const startOrUpdateHeartbeat = (lock, ttlMs) => {
+    const key = heartbeatKey(lock);
+    const existing = heartbeats.get(key);
+    if (existing) {
+      existing.ttlMs = ttlMs;
+      return;
+    }
+    const timer = setInterval(() => {
+      void runHeartbeat(key);
+    }, ACTIVE_LOCK_HEARTBEAT_MS);
+    timer.unref?.();
+    heartbeats.set(key, {
+      inFlight: false,
+      lock,
+      startedAtMs: Date.now(),
+      timer,
+      ttlMs
+    });
+  };
+  const acquireLock = async (threadId, ttlMs) => {
+    const lock = await base.acquireLock(threadId, ttlMs);
+    if (lock && shouldHeartbeatLock(ttlMs)) {
+      startOrUpdateHeartbeat(lock, ttlMs);
+    }
+    return lock;
+  };
+  return {
+    appendToList: (key, value, options2) => base.appendToList(key, value, options2),
+    connect: () => base.connect(),
+    disconnect: async () => {
+      stopAllHeartbeats();
+      await base.disconnect();
+    },
+    subscribe: (threadId) => base.subscribe(threadId),
+    unsubscribe: (threadId) => base.unsubscribe(threadId),
+    isSubscribed: (threadId) => base.isSubscribed(threadId),
+    acquireLock,
+    releaseLock: async (lock) => {
+      stopHeartbeat(lock);
+      await base.releaseLock(lock);
+    },
+    extendLock: async (lock, ttlMs) => {
+      const extended = await base.extendLock(lock, ttlMs);
+      if (extended) {
+        lock.expiresAt = Date.now() + ttlMs;
+        if (shouldHeartbeatLock(ttlMs)) {
+          startOrUpdateHeartbeat(lock, ttlMs);
+        } else {
+          stopHeartbeat(lock);
+        }
+      } else {
+        stopHeartbeat(lock);
+      }
+      return extended;
+    },
+    forceReleaseLock: async (threadId) => {
+      stopHeartbeatsForThread(threadId);
+      await base.forceReleaseLock(threadId);
+    },
+    enqueue: (threadId, entry, maxSize) => base.enqueue(threadId, entry, maxSize),
+    dequeue: (threadId) => base.dequeue(threadId),
+    queueDepth: (threadId) => base.queueDepth(threadId),
+    get: (key) => base.get(key),
+    getList: (key) => base.getList(key),
+    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
+    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
+    delete: (key) => base.delete(key)
+  };
+}
+function withOptionalPrefix(base, prefix) {
+  return prefix ? createPrefixedStateAdapter(base, prefix) : base;
+}
+function createStateAdapter() {
+  const config = getChatConfig();
+  const activeLockMaxAgeMs = config.bot.turnTimeoutMs + ACTIVE_LOCK_TTL_MS;
+  if (config.state.adapter === "memory") {
+    redisStateAdapter = void 0;
+    return createQueuedStateAdapter(
+      withOptionalPrefix(createMemoryState(), config.state.keyPrefix),
+      { activeLockMaxAgeMs }
+    );
+  }
+  if (!config.state.redisUrl) {
+    throw new Error("REDIS_URL is required for durable Slack thread state");
+  }
+  const redisState = createRedisState({
+    url: config.state.redisUrl
+  });
+  redisStateAdapter = redisState;
+  return createQueuedStateAdapter(
+    withOptionalPrefix(redisState, config.state.keyPrefix),
+    { activeLockMaxAgeMs }
+  );
+}
+function getOptionalRedisStateAdapter() {
+  getStateAdapter();
+  return redisStateAdapter;
+}
+async function getConnectedStateContext() {
+  const adapter = getStateAdapter();
+  await adapter.connect();
+  return {
+    redisStateAdapter: getOptionalRedisStateAdapter(),
+    stateAdapter: adapter
+  };
+}
+async function getDefaultRedisStateAdapterFor(adapter) {
+  if (adapter !== stateAdapter) {
+    return void 0;
+  }
+  const context = await getConnectedStateContext();
+  return context.stateAdapter === adapter ? context.redisStateAdapter : void 0;
+}
+function getStateAdapter() {
+  if (!stateAdapter) {
+    stateAdapter = createStateAdapter();
+  }
+  return stateAdapter;
+}
+async function disconnectStateAdapter() {
+  if (!stateAdapter) {
+    return;
+  }
+  try {
+    await stateAdapter.disconnect();
+  } finally {
+    stateAdapter = void 0;
+    redisStateAdapter = void 0;
+  }
+}
+
 export {
   toOptionalTrimmed,
   escapeXml,
+  unescapeXml,
   renderCurrentInstruction,
   unwrapCurrentInstruction,
   TURN_CONTEXT_TAG,
@@ -834,5 +1074,10 @@ export {
   getSlackClientSecret,
   getRuntimeMetadata,
   getSlackReactionConfig,
-  setSlackReactionConfig
+  setSlackReactionConfig,
+  acquireActiveLock,
+  getConnectedStateContext,
+  getDefaultRedisStateAdapterFor,
+  getStateAdapter,
+  disconnectStateAdapter
 };

package/dist/{chunk-BTH37NCU.js → chunk-GVOUCI2O.js}

@@ -3,7 +3,7 @@ import {
   logWarn,
   parseActorUserId,
   setSpanAttributes
-} from "./chunk-S6QKIGRM.js";
+} from "./chunk-WPOJ443W.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames,

package/dist/{chunk-YYBX2BD5.js → chunk-GY34VGP5.js}

@@ -5,7 +5,7 @@ import {
   parseSlackChannelId,
   parseSlackMessageTs,
   parseSlackTeamId
-} from "./chunk-LFLTJQVR.js";
+} from "./chunk-7FBGKXPE.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";