@sentry/junior 0.1.0 → 0.1.1

package/dist/chunk-MM3YNA4F.js

@@ -1,203 +0,0 @@
-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-ZA2IDPVG.js

@@ -1,39 +0,0 @@
-// 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
-};

package/dist/chunk-ZBFSIN6G.js

@@ -1,323 +0,0 @@
-import {
-  hasRedisConfig
-} from "./chunk-GDNDYMGX.js";
-
-// src/chat/state.ts
-import { createRedisState } from "@chat-adapter/state-redis";
-import { createMemoryState } from "@chat-adapter/state-memory";
-var MIN_LOCK_TTL_MS = 1e3 * 60 * 5;
-var QUEUE_INGRESS_DEDUP_PREFIX = "junior:queue_ingress";
-var QUEUE_MESSAGE_PROCESSING_PREFIX = "junior:queue_message";
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-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 AGENT_TURN_SESSION_TTL_MS = 24 * 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 createQueuedStateAdapter(base) {
-  const acquireLock = async (threadId, ttlMs) => {
-    const effectiveTtlMs = Math.max(ttlMs, MIN_LOCK_TTL_MS);
-    const lock = await base.acquireLock(threadId, effectiveTtlMs);
-    return lock;
-  };
-  return {
-    connect: () => base.connect(),
-    disconnect: () => base.disconnect(),
-    subscribe: (threadId) => base.subscribe(threadId),
-    unsubscribe: (threadId) => base.unsubscribe(threadId),
-    isSubscribed: (threadId) => base.isSubscribed(threadId),
-    acquireLock,
-    releaseLock: (lock) => base.releaseLock(lock),
-    extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
-    get: (key) => base.get(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 createStateAdapter() {
-  if (process.env.JUNIOR_STATE_ADAPTER?.trim().toLowerCase() === "memory") {
-    _redisStateAdapter = void 0;
-    return createQueuedStateAdapter(createMemoryState());
-  }
-  if (!hasRedisConfig()) {
-    throw new Error("REDIS_URL is required for durable Slack thread state");
-  }
-  const redisState = createRedisState({
-    url: process.env.REDIS_URL
-  });
-  _redisStateAdapter = redisState;
-  return createQueuedStateAdapter(redisState);
-}
-var _stateAdapter;
-var _redisStateAdapter;
-function getRedisStateAdapter() {
-  if (!_redisStateAdapter) {
-    getStateAdapter();
-  }
-  if (!_redisStateAdapter) {
-    throw new Error("Redis state adapter is unavailable for this runtime");
-  }
-  return _redisStateAdapter;
-}
-function queueMessageKey(rawKey) {
-  return `${QUEUE_MESSAGE_PROCESSING_PREFIX}:${rawKey}`;
-}
-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;
-  }
-}
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function parseAgentTurnSessionCheckpoint(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    const status = parsed.state;
-    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed") {
-      return void 0;
-    }
-    const conversationId = parsed.conversationId;
-    const sessionId = parsed.sessionId;
-    const sliceId = parsed.sliceId;
-    const checkpointVersion = parsed.checkpointVersion;
-    const updatedAtMs = parsed.updatedAtMs;
-    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function getStateAdapter() {
-  if (!_stateAdapter) {
-    _stateAdapter = createStateAdapter();
-  }
-  return _stateAdapter;
-}
-async function claimQueueIngressDedup(rawKey, ttlMs) {
-  await getStateAdapter().connect();
-  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
-  const result = await getRedisStateAdapter().getClient().set(key, "1", {
-    NX: true,
-    PX: ttlMs
-  });
-  return result === "OK";
-}
-async function hasQueueIngressDedup(rawKey) {
-  await getStateAdapter().connect();
-  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
-  const value = await getRedisStateAdapter().getClient().get(key);
-  return typeof value === "string" && value.length > 0;
-}
-async function getQueueMessageProcessingState(rawKey) {
-  await getStateAdapter().connect();
-  const state = await getStateAdapter().get(queueMessageKey(rawKey));
-  return parseQueueMessageState(state);
-}
-async function acquireQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const key = queueMessageKey(args.rawKey);
-  const nowMs = Date.now();
-  const payload = JSON.stringify({
-    status: "processing",
-    updatedAtMs: nowMs,
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().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";
-}
-async function refreshQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const nowMs = Date.now();
-  const payload = JSON.stringify({
-    status: "processing",
-    updatedAtMs: nowMs,
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().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;
-}
-async function completeQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const payload = JSON.stringify({
-    status: "completed",
-    updatedAtMs: Date.now(),
-    ownerToken: args.ownerToken,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().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;
-}
-async function failQueueMessageProcessingOwnership(args) {
-  await getStateAdapter().connect();
-  const payload = JSON.stringify({
-    status: "failed",
-    updatedAtMs: Date.now(),
-    ownerToken: args.ownerToken,
-    errorMessage: args.errorMessage,
-    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
-  });
-  const result = await getRedisStateAdapter().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;
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  await getStateAdapter().connect();
-  const value = await getStateAdapter().get(agentTurnSessionKey(conversationId, sessionId));
-  return parseAgentTurnSessionCheckpoint(value);
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  await getStateAdapter().connect();
-  const existing = await getAgentTurnSessionCheckpoint(args.conversationId, args.sessionId);
-  const checkpoint = {
-    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await getStateAdapter().set(agentTurnSessionKey(args.conversationId, args.sessionId), JSON.stringify(checkpoint), ttlMs);
-  return checkpoint;
-}
-
-export {
-  getStateAdapter,
-  claimQueueIngressDedup,
-  hasQueueIngressDedup,
-  getQueueMessageProcessingState,
-  acquireQueueMessageProcessingOwnership,
-  refreshQueueMessageProcessingOwnership,
-  completeQueueMessageProcessingOwnership,
-  failQueueMessageProcessingOwnership,
-  getAgentTurnSessionCheckpoint,
-  upsertAgentTurnSessionCheckpoint
-};

package/dist/client-3GAEMIQ3.js

@@ -1,10 +0,0 @@
-import {
-  createQueueCallbackHandler,
-  enqueueThreadMessage,
-  getThreadMessageTopic
-} from "./chunk-ZA2IDPVG.js";
-export {
-  createQueueCallbackHandler,
-  enqueueThreadMessage,
-  getThreadMessageTopic
-};