@cuylabs/channel-slack 0.5.1 → 0.7.0

package/dist/{chunk-CMR6B76C.js → chunk-DNVSH7H5.js}

@@ -651,6 +651,406 @@ function createSlackMessagePolicyResolver(config = {}) {
   };
 }
 
+// src/policy/thread-participation.ts
+var DEFAULT_MAX_THREADS = 1e4;
+var DEFAULT_POSTGRES_TABLE = "channel_slack_thread_participation";
+var DEFAULT_POSTGRES_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var DEFAULT_POSTGRES_PRUNE_BATCH_SIZE = 1e3;
+var DEFAULT_POSTGRES_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function resolveSlackThreadParticipationEligibility({
+  activity,
+  policy,
+  stateStore
+}) {
+  if (!stateStore) {
+    return { available: false, reason: "state-store-unavailable" };
+  }
+  if (activity.channelType === "dm") {
+    return { available: false, reason: "direct-message" };
+  }
+  if (activity.channelType !== "channel" && activity.channelType !== "thread") {
+    return { available: false, reason: "unsupported-channel-type" };
+  }
+  if (policy.messagePolicy !== "mentioned-threads") {
+    return {
+      available: false,
+      reason: "message-policy-not-mentioned-threads"
+    };
+  }
+  if (policy.threadReplyPolicy === "mention-required") {
+    return {
+      available: false,
+      reason: "thread-replies-require-mention"
+    };
+  }
+  const threadTs = activity.threadTs ?? activity.messageTs;
+  if (!threadTs) {
+    return { available: false, reason: "missing-thread-timestamp" };
+  }
+  return {
+    available: true,
+    threadKey: createSlackMessagePolicyThreadKey(activity),
+    threadTs
+  };
+}
+function createInMemorySlackThreadParticipationStateStore({
+  maxThreads = DEFAULT_MAX_THREADS,
+  now = () => /* @__PURE__ */ new Date()
+} = {}) {
+  const states = /* @__PURE__ */ new Map();
+  const order = [];
+  const resolvedMaxThreads = Math.max(1, maxThreads);
+  function rememberKey(key) {
+    if (!states.has(key)) {
+      order.push(key);
+    }
+    while (order.length > resolvedMaxThreads) {
+      const oldest = order.shift();
+      if (oldest !== void 0) {
+        states.delete(oldest);
+      }
+    }
+  }
+  return {
+    async get(key) {
+      return states.get(key);
+    },
+    async setQuiet(key, state) {
+      rememberKey(key);
+      states.set(key, {
+        ...state,
+        mode: "quiet",
+        updatedAt: now().toISOString()
+      });
+    },
+    async clear(key) {
+      states.delete(key);
+      const index = order.indexOf(key);
+      if (index >= 0) {
+        order.splice(index, 1);
+      }
+    },
+    async prune() {
+      return { quietThreadsDeleted: 0 };
+    }
+  };
+}
+function createPostgresSlackThreadParticipationStateStore({
+  client,
+  connectionString,
+  ensureSchema = true,
+  onPruneError,
+  pruneBatchSize = DEFAULT_POSTGRES_PRUNE_BATCH_SIZE,
+  pruneIntervalMs = DEFAULT_POSTGRES_PRUNE_INTERVAL_MS,
+  retentionMs = DEFAULT_POSTGRES_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  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 thread participation client is not provided"
+      );
+    }
+    const Pool = await importPostgresPoolConstructor2();
+    activeClient = new Pool({ connectionString });
+    ownsClient = true;
+    return activeClient;
+  }
+  async function ensureInitialized() {
+    const currentClient = await getClient();
+    initialized ??= initializePostgresSlackThreadParticipationState({
+      client: currentClient,
+      ensureSchema,
+      schema,
+      tableName
+    });
+    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 prunePostgresSlackThreadParticipationState({
+      client: currentClient,
+      pruneBatchSize,
+      retentionMs,
+      schema,
+      tableName
+    });
+  }
+  return {
+    async get(key) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT
+          mode,
+          reason,
+          source_message_ts,
+          updated_at,
+          updated_by_user_id
+        FROM ${qualifiedTableName2({ schema, tableName })}
+        WHERE key = $1::text`,
+        [key]
+      );
+      const row = result.rows[0];
+      if (!row || row.mode !== "quiet") {
+        return void 0;
+      }
+      return {
+        mode: "quiet",
+        ...row.reason ? { reason: row.reason } : {},
+        ...row.source_message_ts ? { sourceMessageTs: row.source_message_ts } : {},
+        updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
+        ...row.updated_by_user_id ? { updatedByUserId: row.updated_by_user_id } : {}
+      };
+    },
+    async setQuiet(key, state, context) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `INSERT INTO ${qualifiedTableName2({ schema, tableName })} (
+          key,
+          team_id,
+          channel_id,
+          thread_ts,
+          mode,
+          reason,
+          updated_by_user_id,
+          source_message_ts,
+          updated_at
+        )
+        VALUES ($1::text, $2::text, $3::text, $4::text, 'quiet', $5::text, $6::text, $7::text, now())
+        ON CONFLICT (key) DO UPDATE SET
+          team_id = EXCLUDED.team_id,
+          channel_id = EXCLUDED.channel_id,
+          thread_ts = EXCLUDED.thread_ts,
+          mode = 'quiet',
+          reason = EXCLUDED.reason,
+          updated_by_user_id = EXCLUDED.updated_by_user_id,
+          source_message_ts = EXCLUDED.source_message_ts,
+          updated_at = now()`,
+        [
+          key,
+          context.activity.teamId ?? null,
+          context.activity.channelId,
+          context.activity.threadTs ?? context.activity.messageTs ?? null,
+          state.reason ?? null,
+          state.updatedByUserId ?? null,
+          state.sourceMessageTs ?? context.activity.messageTs ?? null
+        ]
+      );
+    },
+    async clear(key) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `DELETE FROM ${qualifiedTableName2({ schema, tableName })}
+        WHERE key = $1::text`,
+        [key]
+      );
+    },
+    prune,
+    async close() {
+      if (pruneTimer) {
+        clearInterval(pruneTimer);
+        pruneTimer = void 0;
+      }
+      if (ownsClient) {
+        await activeClient?.end?.();
+      }
+    }
+  };
+}
+async function initializePostgresSlackThreadParticipationState({
+  client,
+  ensureSchema = true,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  if (schema && ensureSchema) {
+    await client.query(
+      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier2(schema)}`
+    );
+  }
+  const table = qualifiedTableName2({ schema, tableName });
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${table} (
+      key text PRIMARY KEY,
+      team_id text,
+      channel_id text NOT NULL,
+      thread_ts text,
+      mode text NOT NULL CHECK (mode IN ('quiet')),
+      reason text,
+      updated_by_user_id text,
+      source_message_ts text,
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  const indexPrefix = slackThreadParticipationIndexPrefix({
+    schema,
+    tableName
+  });
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier2(
+      `${indexPrefix}_updated_idx`
+    )} ON ${table} (updated_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier2(
+      `${indexPrefix}_channel_thread_idx`
+    )} ON ${table} (channel_id, thread_ts)`
+  );
+}
+async function prunePostgresSlackThreadParticipationState({
+  client,
+  pruneBatchSize = DEFAULT_POSTGRES_PRUNE_BATCH_SIZE,
+  retentionMs = DEFAULT_POSTGRES_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  if (retentionMs <= 0) {
+    return { quietThreadsDeleted: 0 };
+  }
+  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
+  const table = qualifiedTableName2({ schema, tableName });
+  const result = await client.query(
+    `WITH expired AS (
+      SELECT key
+      FROM ${table}
+      WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')
+      ORDER BY updated_at ASC
+      LIMIT $2::integer
+    )
+    DELETE FROM ${table} target
+    USING expired
+    WHERE target.key = expired.key`,
+    [Math.max(1, Math.floor(retentionMs)), batchSize]
+  );
+  return { quietThreadsDeleted: result.rowCount ?? 0 };
+}
+function qualifiedTableName2({
+  schema,
+  tableName
+}) {
+  return schema ? `${quoteIdentifier2(schema)}.${quoteIdentifier2(tableName)}` : quoteIdentifier2(tableName);
+}
+function quoteIdentifier2(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function slackThreadParticipationIndexPrefix({
+  schema,
+  tableName
+}) {
+  const raw = [schema, tableName].filter(Boolean).join("_");
+  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_thread_participation";
+}
+async function importPostgresPoolConstructor2() {
+  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 createPostgresSlackThreadParticipationStateStore. Install pg or pass a client. ${formatImportError2(
+        error
+      )}`
+    );
+  }
+}
+function formatImportError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/policy/thread-message-policy.ts
+function createAsyncSlackThreadAwareMessagePolicyResolver(config = {}) {
+  const { threadParticipationStore, ...messagePolicyConfig } = config;
+  const resolver = createAsyncSlackMessagePolicyResolver(messagePolicyConfig);
+  async function resolve(activity) {
+    const threadParticipation = await resolveThreadParticipationState({
+      activity,
+      config,
+      stateStore: threadParticipationStore
+    });
+    if (threadParticipation?.quiet) {
+      if (!activity.isMention) {
+        return {
+          accepted: false,
+          activity,
+          reason: "quiet-thread",
+          threadKey: threadParticipation.key,
+          ...threadParticipation.reason ? { threadParticipationReason: threadParticipation.reason } : {},
+          ...threadParticipation.threadTs ? { threadTs: threadParticipation.threadTs } : {}
+        };
+      }
+      await threadParticipationStore?.clear(threadParticipation.key, {
+        activity,
+        key: threadParticipation.key
+      });
+    }
+    const decision = await resolver.resolve(activity);
+    if (!threadParticipation?.quiet || !activity.isMention) {
+      return decision;
+    }
+    return {
+      ...decision,
+      reactivatedThreadParticipation: {
+        threadKey: threadParticipation.key,
+        ...threadParticipation.reason ? { reason: threadParticipation.reason } : {},
+        ...threadParticipation.threadTs ? { threadTs: threadParticipation.threadTs } : {}
+      }
+    };
+  }
+  return {
+    resolve,
+    async resolveMessage(activity) {
+      const decision = await resolve(activity);
+      return decision.accepted ? decision.text : void 0;
+    }
+  };
+}
+async function resolveThreadParticipationState({
+  activity,
+  config,
+  stateStore
+}) {
+  const eligibility = resolveSlackThreadParticipationEligibility({
+    activity,
+    policy: config,
+    stateStore
+  });
+  if (!eligibility.available || !eligibility.threadKey || !stateStore) {
+    return void 0;
+  }
+  const key = eligibility.threadKey;
+  const state = await stateStore.get(key, { activity, key });
+  return state?.mode === "quiet" ? {
+    key,
+    quiet: true,
+    ...state.reason ? { reason: state.reason } : {},
+    ...eligibility.threadTs ? { threadTs: eligibility.threadTs } : {}
+  } : void 0;
+}
+
 export {
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyThreadKey,
@@ -660,5 +1060,11 @@ export {
   initializePostgresSlackMessagePolicyState,
   prunePostgresSlackMessagePolicyState,
   shouldRegisterSlackPassiveChannelMessages,
-  createSlackMessagePolicyResolver
+  createSlackMessagePolicyResolver,
+  resolveSlackThreadParticipationEligibility,
+  createInMemorySlackThreadParticipationStateStore,
+  createPostgresSlackThreadParticipationStateStore,
+  initializePostgresSlackThreadParticipationState,
+  prunePostgresSlackThreadParticipationState,
+  createAsyncSlackThreadAwareMessagePolicyResolver
 };

package/dist/chunk-IRFKUPJN.js

@@ -0,0 +1,235 @@
+// src/views/client.ts
+async function openSlackModal({
+  client,
+  triggerId,
+  view,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "open"
+  )({
+    ...tokenArgs(token),
+    trigger_id: requireTrimmed(triggerId, "triggerId"),
+    view
+  });
+}
+async function pushSlackModal({
+  client,
+  triggerId,
+  view,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "push"
+  )({
+    ...tokenArgs(token),
+    trigger_id: requireTrimmed(triggerId, "triggerId"),
+    view
+  });
+}
+async function updateSlackView({
+  client,
+  view,
+  viewId,
+  externalId,
+  hash,
+  token
+}) {
+  const normalizedViewId = trimOptional(viewId);
+  const normalizedExternalId = trimOptional(externalId);
+  if (!normalizedViewId && !normalizedExternalId) {
+    throw new Error("updateSlackView requires viewId or externalId.");
+  }
+  return await requireViewsMethod(
+    client,
+    "update"
+  )({
+    ...tokenArgs(token),
+    ...normalizedViewId ? { view_id: normalizedViewId } : {},
+    ...normalizedExternalId ? { external_id: normalizedExternalId } : {},
+    ...trimOptional(hash) ? { hash: hash?.trim() } : {},
+    view
+  });
+}
+async function publishSlackHomeView({
+  client,
+  userId,
+  view,
+  hash,
+  token
+}) {
+  return await requireViewsMethod(
+    client,
+    "publish"
+  )({
+    ...tokenArgs(token),
+    user_id: requireTrimmed(userId, "userId"),
+    ...trimOptional(hash) ? { hash: hash?.trim() } : {},
+    view
+  });
+}
+function requireViewsMethod(client, methodName) {
+  const method = client.views?.[methodName];
+  if (typeof method !== "function") {
+    throw new Error(`Slack client does not expose views.${methodName}.`);
+  }
+  return method.bind(client.views);
+}
+function requireTrimmed(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} is required.`);
+  }
+  return trimmed;
+}
+function trimOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function tokenArgs(token) {
+  const trimmed = token?.trim();
+  return trimmed ? { token: trimmed } : {};
+}
+
+// src/views/metadata.ts
+var SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS = 3e3;
+function encodeSlackViewPrivateMetadata(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  const encoded = typeof value === "string" ? value : JSON.stringify(value);
+  if (encoded.length > SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS) {
+    throw new Error(
+      `Slack view private_metadata exceeds ${SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS} characters.`
+    );
+  }
+  return encoded;
+}
+function decodeSlackViewPrivateMetadata(privateMetadata) {
+  const normalized = privateMetadata?.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function readSlackViewPrivateMetadata(view) {
+  return decodeSlackViewPrivateMetadata(view.private_metadata);
+}
+
+// src/views/workflow.ts
+function registerSlackViewWorkflow({
+  boltApp,
+  callbackId,
+  decodePrivateMetadata,
+  onSubmission,
+  onClose,
+  onError
+}) {
+  if (onSubmission) {
+    boltApp.view(
+      { callback_id: callbackId, type: "view_submission" },
+      // Bolt's listener args are structurally stable, but the exact generic
+      // narrows differ between view_submission and view_closed.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async ({ ack, body, client, view }) => {
+        const baseContext = createWorkflowContext({
+          body,
+          client,
+          view
+        });
+        try {
+          const metadata = resolveMetadata(
+            decodePrivateMetadata,
+            view,
+            baseContext
+          );
+          const response = await onSubmission({
+            ...baseContext,
+            metadata
+          });
+          await ack(response);
+        } catch (error) {
+          try {
+            await ack();
+          } catch {
+          }
+          await onError?.(error, baseContext);
+        }
+      }
+    );
+  }
+  if (onClose) {
+    boltApp.view(
+      { callback_id: callbackId, type: "view_closed" },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      async ({ ack, body, client, view }) => {
+        const baseContext = createWorkflowContext({
+          body,
+          client,
+          view
+        });
+        await ack();
+        try {
+          const metadata = resolveMetadata(
+            decodePrivateMetadata,
+            view,
+            baseContext
+          );
+          await onClose({
+            ...baseContext,
+            metadata
+          });
+        } catch (error) {
+          await onError?.(error, baseContext);
+        }
+      }
+    );
+  }
+  return { callbackId };
+}
+function createWorkflowContext({
+  body,
+  client,
+  view
+}) {
+  const bodyRecord = isRecord(body) ? body : {};
+  const user = isRecord(bodyRecord.user) ? bodyRecord.user : {};
+  const team = isRecord(bodyRecord.team) ? bodyRecord.team : {};
+  const enterprise = isRecord(bodyRecord.enterprise) ? bodyRecord.enterprise : {};
+  return {
+    body,
+    client,
+    view,
+    ...typeof view.callback_id === "string" ? { callbackId: view.callback_id } : {},
+    ...typeof bodyRecord.trigger_id === "string" ? { triggerId: bodyRecord.trigger_id } : {},
+    actor: {
+      ...typeof user.id === "string" ? { userId: user.id } : {},
+      ...typeof team.id === "string" ? { teamId: team.id } : {},
+      ...typeof enterprise.id === "string" ? { enterpriseId: enterprise.id } : {}
+    }
+  };
+}
+function resolveMetadata(decodePrivateMetadata, view, context) {
+  return decodePrivateMetadata ? decodePrivateMetadata(view.private_metadata, context) : decodeSlackViewPrivateMetadata(view.private_metadata);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  openSlackModal,
+  pushSlackModal,
+  updateSlackView,
+  publishSlackHomeView,
+  SLACK_VIEW_PRIVATE_METADATA_MAX_CHARS,
+  encodeSlackViewPrivateMetadata,
+  decodeSlackViewPrivateMetadata,
+  readSlackViewPrivateMetadata,
+  registerSlackViewWorkflow
+};