@cuylabs/channel-slack 0.4.0 → 0.5.0

package/dist/chunk-CMR6B76C.js

@@ -0,0 +1,664 @@
+// 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/postgres-state-store.ts
+var DEFAULT_MENTIONED_THREADS_TABLE = "channel_slack_message_policy_threads";
+var DEFAULT_ACCEPTED_MESSAGES_TABLE = "channel_slack_message_policy_messages";
+var DEFAULT_ACCEPTED_MESSAGE_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_MENTIONED_THREAD_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var DEFAULT_PRUNE_BATCH_SIZE = 1e3;
+var DEFAULT_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function createPostgresSlackMessagePolicyStateStore({
+  acceptedMessageRetentionMs = DEFAULT_ACCEPTED_MESSAGE_RETENTION_MS,
+  acceptedMessagesTableName = DEFAULT_ACCEPTED_MESSAGES_TABLE,
+  client,
+  connectionString,
+  ensureSchema = true,
+  mentionedThreadRetentionMs = DEFAULT_MENTIONED_THREAD_RETENTION_MS,
+  mentionedThreadsTableName = DEFAULT_MENTIONED_THREADS_TABLE,
+  onPruneError,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  pruneIntervalMs = DEFAULT_PRUNE_INTERVAL_MS,
+  schema
+}) {
+  let activeClient = client;
+  let ownsClient = false;
+  let initialized;
+  let pruneTimer;
+  async function getClient() {
+    if (activeClient) {
+      return activeClient;
+    }
+    if (!connectionString) {
+      throw new Error(
+        "connectionString is required when a Postgres Slack message policy state client is not provided"
+      );
+    }
+    const Pool = await importPostgresPoolConstructor();
+    activeClient = new Pool({ connectionString });
+    ownsClient = true;
+    return activeClient;
+  }
+  async function ensureInitialized() {
+    const currentClient = await getClient();
+    initialized ??= initializePostgresSlackMessagePolicyState({
+      acceptedMessagesTableName,
+      client: currentClient,
+      ensureSchema,
+      mentionedThreadsTableName,
+      schema
+    });
+    await initialized;
+    startPruneTimer();
+    return currentClient;
+  }
+  function startPruneTimer() {
+    if (pruneTimer || pruneIntervalMs <= 0) {
+      return;
+    }
+    pruneTimer = setInterval(() => {
+      void prune().catch((error) => {
+        onPruneError?.(error);
+      });
+    }, pruneIntervalMs);
+    pruneTimer.unref?.();
+  }
+  async function prune() {
+    const currentClient = await ensureInitialized();
+    return prunePostgresSlackMessagePolicyState({
+      acceptedMessageRetentionMs,
+      acceptedMessagesTableName,
+      client: currentClient,
+      mentionedThreadRetentionMs,
+      mentionedThreadsTableName,
+      pruneBatchSize,
+      schema
+    });
+  }
+  async function claimAcceptedMessage(key, context) {
+    const currentClient = await ensureInitialized();
+    const result = await currentClient.query(
+      `INSERT INTO ${qualifiedTableName({
+        schema,
+        tableName: acceptedMessagesTableName
+      })} (
+        key,
+        team_id,
+        channel_id,
+        thread_ts,
+        message_ts,
+        user_id
+      )
+      VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text)
+      ON CONFLICT (key) DO NOTHING
+      RETURNING key`,
+      [
+        key,
+        context.activity.teamId ?? null,
+        context.activity.channelId,
+        context.activity.threadTs ?? null,
+        context.activity.messageTs ?? null,
+        context.activity.userId
+      ]
+    );
+    return result.rows.length > 0;
+  }
+  return {
+    async getMentionedThread(key) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT original_user_id FROM ${qualifiedTableName({
+          schema,
+          tableName: mentionedThreadsTableName
+        })} WHERE key = $1::text`,
+        [key]
+      );
+      const row = result.rows[0];
+      if (!row) {
+        return void 0;
+      }
+      return row.original_user_id ? { originalUserId: row.original_user_id } : {};
+    },
+    async hasAcceptedMessage(key) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT 1 FROM ${qualifiedTableName({
+          schema,
+          tableName: acceptedMessagesTableName
+        })} WHERE key = $1::text LIMIT 1`,
+        [key]
+      );
+      return result.rows.length > 0;
+    },
+    claimAcceptedMessage,
+    async rememberMentionedThread(key, state, context) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `INSERT INTO ${qualifiedTableName({
+          schema,
+          tableName: mentionedThreadsTableName
+        })} (
+          key,
+          team_id,
+          channel_id,
+          thread_ts,
+          original_user_id,
+          last_message_ts,
+          updated_at
+        )
+        VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, now())
+        ON CONFLICT (key) DO UPDATE SET
+          team_id = EXCLUDED.team_id,
+          channel_id = EXCLUDED.channel_id,
+          thread_ts = EXCLUDED.thread_ts,
+          original_user_id = EXCLUDED.original_user_id,
+          last_message_ts = EXCLUDED.last_message_ts,
+          updated_at = now()`,
+        [
+          key,
+          context.activity.teamId ?? null,
+          context.activity.channelId,
+          context.activity.threadTs ?? context.activity.messageTs ?? null,
+          state.originalUserId ?? null,
+          context.activity.messageTs ?? null
+        ]
+      );
+    },
+    async rememberAcceptedMessage(key, context) {
+      await claimAcceptedMessage(key, context);
+    },
+    prune,
+    async close() {
+      if (pruneTimer) {
+        clearInterval(pruneTimer);
+        pruneTimer = void 0;
+      }
+      if (ownsClient) {
+        await activeClient?.end?.();
+      }
+    }
+  };
+}
+async function initializePostgresSlackMessagePolicyState({
+  acceptedMessagesTableName = DEFAULT_ACCEPTED_MESSAGES_TABLE,
+  client,
+  ensureSchema = true,
+  mentionedThreadsTableName = DEFAULT_MENTIONED_THREADS_TABLE,
+  schema
+}) {
+  if (schema && ensureSchema) {
+    await client.query(
+      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schema)}`
+    );
+  }
+  const mentionedThreadsTable = qualifiedTableName({
+    schema,
+    tableName: mentionedThreadsTableName
+  });
+  const acceptedMessagesTable = qualifiedTableName({
+    schema,
+    tableName: acceptedMessagesTableName
+  });
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${mentionedThreadsTable} (
+      key text PRIMARY KEY,
+      team_id text,
+      channel_id text NOT NULL,
+      thread_ts text,
+      original_user_id text,
+      last_message_ts text,
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${acceptedMessagesTable} (
+      key text PRIMARY KEY,
+      team_id text,
+      channel_id text NOT NULL,
+      thread_ts text,
+      message_ts text,
+      user_id text NOT NULL,
+      created_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  const mentionedIndexPrefix = slackPolicyIndexPrefix({
+    schema,
+    tableName: mentionedThreadsTableName
+  });
+  const acceptedIndexPrefix = slackPolicyIndexPrefix({
+    schema,
+    tableName: acceptedMessagesTableName
+  });
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${mentionedIndexPrefix}_updated_idx`
+    )} ON ${mentionedThreadsTable} (updated_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${mentionedIndexPrefix}_channel_thread_idx`
+    )} ON ${mentionedThreadsTable} (channel_id, thread_ts)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${acceptedIndexPrefix}_created_idx`
+    )} ON ${acceptedMessagesTable} (created_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${acceptedIndexPrefix}_channel_message_idx`
+    )} ON ${acceptedMessagesTable} (channel_id, message_ts)`
+  );
+}
+async function prunePostgresSlackMessagePolicyState({
+  acceptedMessageRetentionMs = DEFAULT_ACCEPTED_MESSAGE_RETENTION_MS,
+  acceptedMessagesTableName = DEFAULT_ACCEPTED_MESSAGES_TABLE,
+  client,
+  mentionedThreadRetentionMs = DEFAULT_MENTIONED_THREAD_RETENTION_MS,
+  mentionedThreadsTableName = DEFAULT_MENTIONED_THREADS_TABLE,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  schema
+}) {
+  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
+  const mentionedThreadsDeleted = mentionedThreadRetentionMs > 0 ? await deleteOldRows({
+    batchSize,
+    client,
+    retentionMs: mentionedThreadRetentionMs,
+    tableName: qualifiedTableName({
+      schema,
+      tableName: mentionedThreadsTableName
+    }),
+    timestampColumn: "updated_at"
+  }) : 0;
+  const acceptedMessagesDeleted = acceptedMessageRetentionMs > 0 ? await deleteOldRows({
+    batchSize,
+    client,
+    retentionMs: acceptedMessageRetentionMs,
+    tableName: qualifiedTableName({
+      schema,
+      tableName: acceptedMessagesTableName
+    }),
+    timestampColumn: "created_at"
+  }) : 0;
+  return { acceptedMessagesDeleted, mentionedThreadsDeleted };
+}
+async function deleteOldRows({
+  batchSize,
+  client,
+  retentionMs,
+  tableName,
+  timestampColumn
+}) {
+  const result = await client.query(
+    `WITH expired AS (
+      SELECT key
+      FROM ${tableName}
+      WHERE ${quoteIdentifier(timestampColumn)} < now() - ($1::bigint * interval '1 millisecond')
+      ORDER BY ${quoteIdentifier(timestampColumn)} ASC
+      LIMIT $2::integer
+    )
+    DELETE FROM ${tableName} target
+    USING expired
+    WHERE target.key = expired.key`,
+    [Math.max(1, Math.floor(retentionMs)), batchSize]
+  );
+  return result.rowCount ?? 0;
+}
+function qualifiedTableName({
+  schema,
+  tableName
+}) {
+  return schema ? `${quoteIdentifier(schema)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function slackPolicyIndexPrefix({
+  schema,
+  tableName
+}) {
+  const raw = [schema, tableName].filter(Boolean).join("_");
+  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_policy";
+}
+async function importPostgresPoolConstructor() {
+  const dynamicImport = new Function(
+    "specifier",
+    "return import(specifier)"
+  );
+  try {
+    const pg = await dynamicImport("pg");
+    return pg.Pool;
+  } catch (error) {
+    throw new Error(
+      `The "pg" package is required when using connectionString with createPostgresSlackMessagePolicyStateStore. Install pg or pass a client. ${formatImportError(
+        error
+      )}`
+    );
+  }
+}
+function formatImportError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// 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,
+  createPostgresSlackMessagePolicyStateStore,
+  initializePostgresSlackMessagePolicyState,
+  prunePostgresSlackMessagePolicyState,
+  shouldRegisterSlackPassiveChannelMessages,
+  createSlackMessagePolicyResolver
+};