@cuylabs/channel-slack 0.1.0

package/dist/chunk-BODPT4I6.js

@@ -0,0 +1,322 @@
+// src/policy/message/keys.ts
+function createSlackMessagePolicyMessageKey(activity) {
+  if (!activity.messageTs) {
+    return void 0;
+  }
+  return `${activity.teamId ?? "unknown"}:${activity.channelId}:${activity.messageTs}`;
+}
+function createSlackMessagePolicyThreadKey(activity) {
+  return `${activity.teamId ?? "unknown"}:${activity.channelId}:${activity.threadTs ?? activity.messageTs ?? "unthreaded"}`;
+}
+
+// src/policy/message/state-store.ts
+var DEFAULT_MAX_MENTIONED_THREADS = 1e4;
+var DEFAULT_MAX_ACCEPTED_MESSAGES = 1e4;
+function createInMemorySlackMessagePolicyStateStore({
+  maxAcceptedMessages = DEFAULT_MAX_ACCEPTED_MESSAGES,
+  maxMentionedThreads = DEFAULT_MAX_MENTIONED_THREADS
+} = {}) {
+  const mentionedThreads = /* @__PURE__ */ new Map();
+  const mentionedThreadOrder = [];
+  const acceptedMessageKeys = /* @__PURE__ */ new Set();
+  const acceptedMessageOrder = [];
+  function claimAcceptedMessageKey(key) {
+    if (acceptedMessageKeys.has(key)) {
+      return false;
+    }
+    acceptedMessageKeys.add(key);
+    acceptedMessageOrder.push(key);
+    trimSetByOrder(
+      acceptedMessageKeys,
+      acceptedMessageOrder,
+      maxAcceptedMessages
+    );
+    return true;
+  }
+  return {
+    getMentionedThread(key) {
+      return mentionedThreads.get(key);
+    },
+    hasAcceptedMessage(key) {
+      return acceptedMessageKeys.has(key);
+    },
+    claimAcceptedMessage(key) {
+      return claimAcceptedMessageKey(key);
+    },
+    rememberMentionedThread(key, state) {
+      if (!mentionedThreads.has(key)) {
+        mentionedThreadOrder.push(key);
+      }
+      mentionedThreads.set(key, state);
+      trimMapByOrder(
+        mentionedThreads,
+        mentionedThreadOrder,
+        maxMentionedThreads
+      );
+    },
+    rememberAcceptedMessage(key) {
+      claimAcceptedMessageKey(key);
+    }
+  };
+}
+function trimMapByOrder(map, order, maxEntries) {
+  if (!Number.isFinite(maxEntries) || maxEntries <= 0) {
+    map.clear();
+    order.length = 0;
+    return;
+  }
+  while (order.length > maxEntries) {
+    const oldest = order.shift();
+    if (oldest !== void 0) {
+      map.delete(oldest);
+    }
+  }
+}
+function trimSetByOrder(set, order, maxEntries) {
+  if (!Number.isFinite(maxEntries) || maxEntries <= 0) {
+    set.clear();
+    order.length = 0;
+    return;
+  }
+  while (order.length > maxEntries) {
+    const oldest = order.shift();
+    if (oldest !== void 0) {
+      set.delete(oldest);
+    }
+  }
+}
+
+// src/policy/message/async-resolver.ts
+function createAsyncSlackMessagePolicyResolver(config = {}) {
+  const allowedChannelIds = new Set(config.allowedChannelIds ?? []);
+  const messagePolicy = config.messagePolicy ?? "disabled";
+  const threadReplyPolicy = config.threadReplyPolicy ?? "mention-required";
+  const stateStore = config.stateStore ?? createInMemorySlackMessagePolicyStateStore({
+    maxAcceptedMessages: config.maxAcceptedMessages,
+    maxMentionedThreads: config.maxMentionedThreads
+  });
+  async function rememberMentionedThread(activity) {
+    const key = createSlackMessagePolicyThreadKey(activity);
+    const originalUserId = activity.parentUserId ?? activity.userId;
+    await stateStore.rememberMentionedThread(
+      key,
+      { originalUserId },
+      {
+        activity,
+        key
+      }
+    );
+  }
+  async function claimAcceptedMessage(activity) {
+    const key = createSlackMessagePolicyMessageKey(activity);
+    if (!key) {
+      return true;
+    }
+    const context = { activity, key };
+    if (stateStore.claimAcceptedMessage) {
+      return await stateStore.claimAcceptedMessage(key, context);
+    }
+    if (await stateStore.hasAcceptedMessage(key, context)) {
+      return false;
+    }
+    await stateStore.rememberAcceptedMessage(key, context);
+    return true;
+  }
+  async function isDuplicate(activity) {
+    const key = createSlackMessagePolicyMessageKey(activity);
+    return Boolean(
+      key && await stateStore.hasAcceptedMessage(key, { activity, key })
+    );
+  }
+  async function accept(activity, reason) {
+    if (!await claimAcceptedMessage(activity)) {
+      return reject(activity, "duplicate-message-event");
+    }
+    return {
+      accepted: true,
+      activity,
+      reason,
+      text: activity.text
+    };
+  }
+  function reject(activity, reason) {
+    return {
+      accepted: false,
+      activity,
+      reason
+    };
+  }
+  async function resolve(activity) {
+    if (activity.isMention) {
+      await rememberMentionedThread(activity);
+      return accept(activity, "bot-mentioned");
+    }
+    if (await isDuplicate(activity)) {
+      return reject(activity, "duplicate-message-event");
+    }
+    if (activity.channelType === "dm") {
+      return accept(activity, "direct-message");
+    }
+    if (messagePolicy === "disabled") {
+      return reject(activity, "passive-channel-messages-disabled");
+    }
+    if (messagePolicy === "any-added-channel") {
+      return accept(activity, "any-added-channel");
+    }
+    if (messagePolicy === "allowed-channels") {
+      return allowedChannelIds.has(activity.channelId) ? accept(activity, "allowed-channel") : reject(activity, "channel-not-allowed");
+    }
+    const threadKey = createSlackMessagePolicyThreadKey(activity);
+    const threadState = await stateStore.getMentionedThread(threadKey, {
+      activity,
+      key: threadKey
+    });
+    if (!threadState) {
+      return reject(activity, "thread-not-mentioned");
+    }
+    if (threadReplyPolicy === "mention-required") {
+      return reject(activity, "thread-reply-mention-required");
+    }
+    if (threadReplyPolicy === "original-user" && threadState.originalUserId && activity.userId !== threadState.originalUserId) {
+      return reject(activity, "thread-reply-not-original-user");
+    }
+    return accept(activity, "mentioned-thread-reply");
+  }
+  return {
+    resolve,
+    async resolveMessage(activity) {
+      const decision = await resolve(activity);
+      return decision.accepted ? decision.text : void 0;
+    }
+  };
+}
+
+// src/policy/message/passive.ts
+function shouldRegisterSlackPassiveChannelMessages(config = {}) {
+  const messagePolicy = config.messagePolicy ?? "disabled";
+  const threadReplyPolicy = config.threadReplyPolicy ?? "mention-required";
+  if (messagePolicy === "disabled") {
+    return false;
+  }
+  if (messagePolicy === "mentioned-threads" && threadReplyPolicy === "mention-required") {
+    return false;
+  }
+  if (messagePolicy === "allowed-channels") {
+    return Boolean(config.allowedChannelIds?.length);
+  }
+  return true;
+}
+
+// src/policy/message/resolver.ts
+function createSlackMessagePolicyResolver(config = {}) {
+  const allowedChannelIds = new Set(config.allowedChannelIds ?? []);
+  const messagePolicy = config.messagePolicy ?? "disabled";
+  const threadReplyPolicy = config.threadReplyPolicy ?? "mention-required";
+  const stateStore = config.stateStore ?? createInMemorySlackMessagePolicyStateStore({
+    maxAcceptedMessages: config.maxAcceptedMessages,
+    maxMentionedThreads: config.maxMentionedThreads
+  });
+  function rememberMentionedThread(activity) {
+    const key = createSlackMessagePolicyThreadKey(activity);
+    const originalUserId = activity.parentUserId ?? activity.userId;
+    stateStore.rememberMentionedThread(
+      key,
+      { originalUserId },
+      {
+        activity,
+        key
+      }
+    );
+  }
+  function claimAcceptedMessage(activity) {
+    const key = createSlackMessagePolicyMessageKey(activity);
+    if (!key) {
+      return true;
+    }
+    const context = { activity, key };
+    if (stateStore.claimAcceptedMessage) {
+      return stateStore.claimAcceptedMessage(key, context);
+    }
+    if (stateStore.hasAcceptedMessage(key, context)) {
+      return false;
+    }
+    stateStore.rememberAcceptedMessage(key, context);
+    return true;
+  }
+  function isDuplicate(activity) {
+    const key = createSlackMessagePolicyMessageKey(activity);
+    return Boolean(
+      key && stateStore.hasAcceptedMessage(key, { activity, key })
+    );
+  }
+  function accept(activity, reason) {
+    if (!claimAcceptedMessage(activity)) {
+      return reject(activity, "duplicate-message-event");
+    }
+    return {
+      accepted: true,
+      activity,
+      reason,
+      text: activity.text
+    };
+  }
+  function reject(activity, reason) {
+    return {
+      accepted: false,
+      activity,
+      reason
+    };
+  }
+  function resolve(activity) {
+    if (activity.isMention) {
+      rememberMentionedThread(activity);
+      return accept(activity, "bot-mentioned");
+    }
+    if (isDuplicate(activity)) {
+      return reject(activity, "duplicate-message-event");
+    }
+    if (activity.channelType === "dm") {
+      return accept(activity, "direct-message");
+    }
+    if (messagePolicy === "disabled") {
+      return reject(activity, "passive-channel-messages-disabled");
+    }
+    if (messagePolicy === "any-added-channel") {
+      return accept(activity, "any-added-channel");
+    }
+    if (messagePolicy === "allowed-channels") {
+      return allowedChannelIds.has(activity.channelId) ? accept(activity, "allowed-channel") : reject(activity, "channel-not-allowed");
+    }
+    const threadKey = createSlackMessagePolicyThreadKey(activity);
+    const threadState = stateStore.getMentionedThread(threadKey, {
+      activity,
+      key: threadKey
+    });
+    if (!threadState) {
+      return reject(activity, "thread-not-mentioned");
+    }
+    if (threadReplyPolicy === "mention-required") {
+      return reject(activity, "thread-reply-mention-required");
+    }
+    if (threadReplyPolicy === "original-user" && threadState.originalUserId && activity.userId !== threadState.originalUserId) {
+      return reject(activity, "thread-reply-not-original-user");
+    }
+    return accept(activity, "mentioned-thread-reply");
+  }
+  return {
+    resolve,
+    resolveMessage(activity) {
+      const decision = resolve(activity);
+      return decision.accepted ? decision.text : void 0;
+    }
+  };
+}
+
+export {
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyThreadKey,
+  createInMemorySlackMessagePolicyStateStore,
+  createAsyncSlackMessagePolicyResolver,
+  shouldRegisterSlackPassiveChannelMessages,
+  createSlackMessagePolicyResolver
+};

package/dist/chunk-FPCE5V5Y.js

@@ -0,0 +1,292 @@
+// src/shared/activity/classify.ts
+function resolveSlackChannelType(channelId, threadTs, inReplyToMessage) {
+  if (channelId.startsWith("D")) return "dm";
+  if (channelId.startsWith("G")) return "group";
+  if (inReplyToMessage || threadTs) return "thread";
+  return "channel";
+}
+function stripLeadingMentions(text) {
+  return text.replace(/^(<@[A-Z0-9]+>\s*)+/i, "").trim();
+}
+function isProcessableMessage(payload) {
+  if (payload.bot_id || payload.subtype === "bot_message") return false;
+  if (payload.subtype === "message_changed" || payload.subtype === "message_deleted" || payload.subtype === "message_replied") {
+    return false;
+  }
+  if (!payload.user) return false;
+  return true;
+}
+
+// src/shared/activity/text.ts
+function extractSlackMessageText(payload, options = {}) {
+  const payloadText = prepareExtractedText(payload?.text, options);
+  const blocksText = prepareExtractedBlocksText(payload?.blocks, options);
+  const attachmentsText = prepareExtractedText(
+    extractSlackAttachmentsText(payload?.attachments),
+    options
+  );
+  return joinTextParts([
+    choosePrimarySlackText({ payloadText, blocksText }),
+    attachmentsText
+  ]);
+}
+function extractSlackBlocksText(blocks) {
+  return extractSlackBlocksTextResult(blocks)?.text ?? "";
+}
+function extractSlackBlocksTextResult(blocks) {
+  if (!Array.isArray(blocks)) {
+    return void 0;
+  }
+  const parts = [];
+  let hasRichText = false;
+  for (const block of blocks) {
+    const record = readRecord(block);
+    if (readString(record?.type) === "rich_text") {
+      hasRichText = true;
+    }
+    parts.push(...extractBlockText(block));
+  }
+  const text = joinTextParts(parts);
+  return text ? { text, hasRichText } : void 0;
+}
+function extractSlackAttachmentsText(attachments) {
+  if (!Array.isArray(attachments)) {
+    return "";
+  }
+  return joinTextParts(
+    attachments.flatMap((attachment) => extractAttachmentText(attachment))
+  );
+}
+function extractBlockText(block) {
+  const record = readRecord(block);
+  if (!record) {
+    return [];
+  }
+  const type = readString(record.type);
+  if (type === "rich_text") {
+    return extractRichTextElements(record.elements);
+  }
+  if (type === "section") {
+    return [
+      ...extractTextObject(record.text),
+      ...readArray(record.fields).flatMap((field) => extractTextObject(field)),
+      ...extractAccessoryText(record.accessory)
+    ];
+  }
+  if (type === "context") {
+    return readArray(record.elements).flatMap((element) => [
+      ...extractTextObject(element),
+      ...extractImageText(element)
+    ]);
+  }
+  if (type === "header") {
+    return extractTextObject(record.text);
+  }
+  if (type === "image") {
+    return extractImageText(record);
+  }
+  if (type === "video") {
+    return [
+      ...extractTextObject(record.title),
+      ...extractTextObject(record.description),
+      ...readTextField(record.alt_text)
+    ];
+  }
+  return [];
+}
+function extractRichTextElements(elements) {
+  return readArray(elements).flatMap((element) => {
+    const record = readRecord(element);
+    if (!record) {
+      return [];
+    }
+    const type = readString(record.type);
+    if (type === "rich_text_section" || type === "rich_text_quote" || type === "rich_text_preformatted") {
+      return [joinInlineRichText(record.elements)];
+    }
+    if (type === "rich_text_list") {
+      return readArray(record.elements).map(
+        (item) => joinTextParts(extractRichTextElements([item]))
+      );
+    }
+    return extractInlineRichTextElement(record);
+  });
+}
+function joinInlineRichText(elements) {
+  return readArray(elements).flatMap((element) => extractInlineRichTextElement(readRecord(element))).join("");
+}
+function extractInlineRichTextElement(record) {
+  if (!record) {
+    return [];
+  }
+  const type = readString(record.type);
+  if (type === "text") {
+    return readRawTextField(record.text);
+  }
+  if (type === "emoji") {
+    const name = readString(record.name);
+    return name ? [`:${name}:`] : [];
+  }
+  if (type === "user") {
+    const userId = readString(record.user_id);
+    return userId ? [`<@${userId}>`] : [];
+  }
+  if (type === "channel") {
+    const channelId = readString(record.channel_id);
+    return channelId ? [`<#${channelId}>`] : [];
+  }
+  if (type === "usergroup") {
+    const usergroupId = readString(record.usergroup_id);
+    return usergroupId ? [`<!subteam^${usergroupId}>`] : [];
+  }
+  if (type === "link") {
+    return readLinkText(record);
+  }
+  if (type === "broadcast") {
+    const range = readString(record.range);
+    return range ? [`<!${range}>`] : [];
+  }
+  if (type === "date") {
+    return readTextField(record.fallback);
+  }
+  if (type === "color") {
+    return [];
+  }
+  return extractRichTextElements(record.elements);
+}
+function extractAttachmentText(attachment) {
+  const record = readRecord(attachment);
+  if (!record) {
+    return [];
+  }
+  const richParts = [
+    ...readTextField(record.pretext),
+    ...readAttachmentTitle(record),
+    ...readTextField(record.text),
+    ...readArray(record.fields).flatMap(
+      (field) => extractAttachmentFieldText(field)
+    )
+  ];
+  return richParts.length > 0 ? richParts : readTextField(record.fallback);
+}
+function extractAttachmentFieldText(field) {
+  const record = readRecord(field);
+  if (!record) {
+    return [];
+  }
+  return [...readTextField(record.title), ...readTextField(record.value)];
+}
+function extractTextObject(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return [];
+  }
+  return readTextField(record.text);
+}
+function extractAccessoryText(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return [];
+  }
+  const type = readString(record.type);
+  if (type === "image") {
+    return extractImageText(record);
+  }
+  return [];
+}
+function extractImageText(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return [];
+  }
+  return [
+    ...extractTextObject(record.title),
+    ...readTextField(record.alt_text)
+  ];
+}
+function readAttachmentTitle(record) {
+  const title = normalizeText(record.title);
+  const titleLink = normalizeText(record.title_link);
+  if (title && titleLink) {
+    return [formatLinkText(title, titleLink)];
+  }
+  return title ? [title] : [];
+}
+function readLinkText(record) {
+  const url = normalizeText(record.url);
+  const text = normalizeText(record.text);
+  if (url && text) {
+    return [formatLinkText(text, url)];
+  }
+  return readTextField(text ?? url);
+}
+function formatLinkText(text, url) {
+  return text === url ? url : `${text} (${url})`;
+}
+function readTextField(value) {
+  const text = normalizeText(value);
+  return text ? [text] : [];
+}
+function prepareExtractedText(value, options) {
+  const text = normalizeText(value);
+  if (!text) {
+    return void 0;
+  }
+  const prepared = options.stripLeadingMentions ? stripLeadingMentions(text) : text;
+  return normalizeText(prepared);
+}
+function prepareExtractedBlocksText(blocks, options) {
+  const extracted = extractSlackBlocksTextResult(blocks);
+  if (!extracted) {
+    return void 0;
+  }
+  const text = prepareExtractedText(extracted.text, options);
+  return text ? { ...extracted, text } : void 0;
+}
+function choosePrimarySlackText(context) {
+  const { payloadText, blocksText } = context;
+  if (!blocksText) {
+    return payloadText;
+  }
+  if (!payloadText) {
+    return blocksText.text;
+  }
+  if (blocksText.hasRichText && blocksText.text.length > payloadText.length) {
+    return blocksText.text;
+  }
+  if (blocksText.text.length > payloadText.length && blocksText.text.startsWith(payloadText)) {
+    return blocksText.text;
+  }
+  return payloadText;
+}
+function readRawTextField(value) {
+  return typeof value === "string" && value.length > 0 ? [value] : [];
+}
+function joinTextParts(parts) {
+  return parts.map((part) => part?.trim()).filter(Boolean).join("\n").trim();
+}
+function normalizeText(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+export {
+  resolveSlackChannelType,
+  stripLeadingMentions,
+  isProcessableMessage,
+  extractSlackMessageText,
+  extractSlackBlocksText,
+  extractSlackAttachmentsText
+};