@cuylabs/channel-slack 0.5.0 → 0.6.0

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,71 @@
+import { g as SlackIdentityExpectations, b as SlackAuthTestIdentity } from '../inspect-BpY5JA0K.js';
+export { I as InspectSlackConnectionOptions, a as InspectSlackTokenScopesOptions, S as SlackApiInspectionError, c as SlackConnectionInspection, d as SlackConnectionInspectionFinding, e as SlackConnectionInspectionFindingSeverity, f as SlackDiagnosticsClient, h as SlackIdentityMismatch, i as SlackScopeInspection, j as SlackScopeInspectionMethod, k as SlackScopeInspectionMethodError, l as SlackTokenSource, m as compareSlackIdentity, n as formatSlackIdentityMismatches, o as inspectSlackConnection, p as inspectSlackTokenScopes, q as normalizeSlackAuthTestIdentity } from '../inspect-BpY5JA0K.js';
+import { d as SlackSocketModeRuntimePolicy } from '../runtime-BNBHOZSQ.js';
+import '@slack/bolt';
+import '../logging-Bl3HfcC8.js';
+
+interface SlackPayloadDebugSummary {
+    rawArgs: unknown;
+    rawArgsActionTokenPaths: string[];
+    rawArgsKeyPaths: string[];
+    rawArgsTokenLikePaths: string[];
+    slackActivity: unknown;
+    threadContext: unknown;
+}
+declare function summarizeSlackPayloadDebug({ rawArgs, slackActivity, threadContext, }: {
+    rawArgs?: unknown;
+    slackActivity: unknown;
+    threadContext: unknown;
+}): SlackPayloadDebugSummary;
+declare function selectSlackRawArgsForDebug(rawArgs: unknown): unknown;
+declare function selectSlackBodyForDebug(body: unknown): unknown;
+declare function redactSlackDebugValue(value: unknown, depth?: number): unknown;
+declare function collectJsonKeyPaths(value: unknown): string[];
+declare function findJsonKeyPaths(value: unknown, predicate: (key: string) => boolean): string[];
+
+type SlackStartupReadinessTransport = "http" | "socket";
+interface SlackStartupReadinessConfig extends SlackIdentityExpectations {
+    authMode: "single-workspace" | string;
+    botToken?: string;
+    enabled: boolean;
+    socketModeRuntimePolicy?: SlackSocketModeRuntimePolicy;
+    transport: SlackStartupReadinessTransport;
+}
+interface SlackStartupReadinessOptions {
+    clientFactory?: (botToken: string) => SlackStartupAuthTestClient;
+    config: SlackStartupReadinessConfig;
+    logger?: SlackStartupReadinessLogger;
+}
+interface SlackStartupReadinessResult {
+    authMode: string;
+    identity?: SlackAuthTestIdentity;
+    identityCheck: "disabled" | "passed" | "skipped";
+    socketModeRuntimePolicy?: SlackSocketModeRuntimePolicy;
+    transport: SlackStartupReadinessTransport;
+}
+interface SlackStartupAuthTestClient {
+    auth: {
+        test(): Promise<SlackStartupAuthTestResponse>;
+    };
+}
+interface SlackStartupAuthTestResponse {
+    bot_id?: string;
+    error?: string;
+    ok?: boolean;
+    team?: string;
+    team_id?: string;
+    url?: string;
+    user_id?: string;
+}
+interface SlackStartupReadinessLogger {
+    debug?(message: string, attributes?: Record<string, unknown>): void;
+    info?(message: string, attributes?: Record<string, unknown>): void;
+    warn?(message: string, attributes?: Record<string, unknown>): void;
+}
+declare class SlackStartupReadinessError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+declare function runSlackStartupReadiness({ clientFactory, config, logger, }: SlackStartupReadinessOptions): Promise<SlackStartupReadinessResult>;
+
+export { SlackAuthTestIdentity, SlackIdentityExpectations, type SlackPayloadDebugSummary, type SlackStartupAuthTestClient, type SlackStartupAuthTestResponse, type SlackStartupReadinessConfig, SlackStartupReadinessError, type SlackStartupReadinessLogger, type SlackStartupReadinessOptions, type SlackStartupReadinessResult, type SlackStartupReadinessTransport, collectJsonKeyPaths, findJsonKeyPaths, redactSlackDebugValue, runSlackStartupReadiness, selectSlackBodyForDebug, selectSlackRawArgsForDebug, summarizeSlackPayloadDebug };

package/dist/{diagnostics.js → diagnostics/index.js}

@@ -1,4 +1,5 @@
 import {
+  SlackStartupReadinessError,
   collectJsonKeyPaths,
   compareSlackIdentity,
   findJsonKeyPaths,
@@ -7,11 +8,13 @@ import {
   inspectSlackTokenScopes,
   normalizeSlackAuthTestIdentity,
   redactSlackDebugValue,
+  runSlackStartupReadiness,
   selectSlackBodyForDebug,
   selectSlackRawArgsForDebug,
   summarizeSlackPayloadDebug
-} from "./chunk-IDVDMJ5U.js";
+} from "../chunk-6JSGIVQH.js";
 export {
+  SlackStartupReadinessError,
   collectJsonKeyPaths,
   compareSlackIdentity,
   findJsonKeyPaths,
@@ -20,6 +23,7 @@ export {
   inspectSlackTokenScopes,
   normalizeSlackAuthTestIdentity,
   redactSlackDebugValue,
+  runSlackStartupReadiness,
   selectSlackBodyForDebug,
   selectSlackRawArgsForDebug,
   summarizeSlackPayloadDebug

package/dist/entrypoints/index.d.ts

@@ -0,0 +1,120 @@
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
+
+interface RawSlackSlashCommandPayload {
+    command?: string;
+    text?: string;
+    response_url?: string;
+    trigger_id?: string;
+    user_id?: string;
+    user_name?: string;
+    team_id?: string;
+    team_domain?: string;
+    channel_id?: string;
+    channel_name?: string;
+    api_app_id?: string;
+    enterprise_id?: string;
+    enterprise_name?: string;
+    is_enterprise_install?: string | boolean;
+    [key: string]: unknown;
+}
+interface SlackSlashCommandEntrypoint {
+    kind: "slash-command";
+    command: string;
+    activity: SlackActivityInfo;
+    triggerId?: string;
+    responseUrl?: string;
+    userName?: string;
+    channelName?: string;
+    teamDomain?: string;
+    appId?: string;
+    enterpriseId?: string;
+    enterpriseName?: string;
+    isEnterpriseInstall?: boolean;
+}
+declare function parseSlackSlashCommandEntrypoint(payload: RawSlackSlashCommandPayload): SlackSlashCommandEntrypoint;
+
+interface RawSlackShortcutUser {
+    id?: string;
+    name?: string;
+    username?: string;
+    team_id?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutTeam {
+    id?: string;
+    domain?: string;
+    enterprise_id?: string;
+    enterprise_name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutEnterprise {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutChannel {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutMessage {
+    type?: string;
+    user?: string;
+    channel?: string;
+    ts?: string;
+    thread_ts?: string;
+    text?: string;
+    blocks?: unknown[];
+    attachments?: unknown[];
+    [key: string]: unknown;
+}
+interface RawSlackShortcutPayload {
+    type?: "shortcut" | "message_action" | string;
+    callback_id?: string;
+    trigger_id?: string;
+    response_url?: string;
+    action_ts?: string;
+    message_ts?: string;
+    user?: RawSlackShortcutUser;
+    team?: RawSlackShortcutTeam | null;
+    enterprise?: RawSlackShortcutEnterprise;
+    channel?: RawSlackShortcutChannel;
+    message?: RawSlackShortcutMessage;
+    is_enterprise_install?: boolean;
+    [key: string]: unknown;
+}
+interface SlackShortcutEntrypointBase {
+    callbackId: string;
+    triggerId?: string;
+    actionTs?: string;
+    userId: string;
+    userName?: string;
+    teamId?: string;
+    teamDomain?: string;
+    enterpriseId?: string;
+    enterpriseName?: string;
+    isEnterpriseInstall?: boolean;
+}
+interface SlackGlobalShortcutEntrypoint extends SlackShortcutEntrypointBase {
+    kind: "global-shortcut";
+}
+interface SlackMessageShortcutSelection {
+    channelId: string;
+    channelName?: string;
+    messageTs?: string;
+    threadTs?: string;
+    userId?: string;
+    text: string;
+}
+interface SlackMessageShortcutEntrypoint extends SlackShortcutEntrypointBase {
+    kind: "message-shortcut";
+    activity: SlackActivityInfo;
+    responseUrl?: string;
+    selectedMessage: SlackMessageShortcutSelection;
+}
+type SlackShortcutEntrypoint = SlackGlobalShortcutEntrypoint | SlackMessageShortcutEntrypoint;
+declare function parseSlackShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackShortcutEntrypoint;
+declare function parseSlackGlobalShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackGlobalShortcutEntrypoint;
+declare function parseSlackMessageShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackMessageShortcutEntrypoint;
+
+export { type RawSlackShortcutChannel, type RawSlackShortcutEnterprise, type RawSlackShortcutMessage, type RawSlackShortcutPayload, type RawSlackShortcutTeam, type RawSlackShortcutUser, type RawSlackSlashCommandPayload, type SlackGlobalShortcutEntrypoint, type SlackMessageShortcutEntrypoint, type SlackMessageShortcutSelection, type SlackShortcutEntrypoint, type SlackShortcutEntrypointBase, type SlackSlashCommandEntrypoint, parseSlackGlobalShortcutEntrypoint, parseSlackMessageShortcutEntrypoint, parseSlackShortcutEntrypoint, parseSlackSlashCommandEntrypoint };

package/dist/entrypoints/index.js

@@ -0,0 +1,132 @@
+import {
+  extractSlackMessageText,
+  resolveSlackChannelType
+} from "../chunk-FPCE5V5Y.js";
+
+// src/entrypoints/commands.ts
+function parseSlackSlashCommandEntrypoint(payload) {
+  const channelId = readString(payload.channel_id) ?? "unknown";
+  const teamId = readString(payload.team_id);
+  const text = readString(payload.text) ?? "";
+  const triggerId = readString(payload.trigger_id);
+  const responseUrl = readString(payload.response_url);
+  const userName = readString(payload.user_name);
+  const channelName = readString(payload.channel_name);
+  const teamDomain = readString(payload.team_domain);
+  const appId = readString(payload.api_app_id);
+  const enterpriseId = readString(payload.enterprise_id);
+  const enterpriseName = readString(payload.enterprise_name);
+  const activity = {
+    channelId,
+    channelType: resolveSlackChannelType(channelId, void 0, false),
+    userId: readString(payload.user_id) ?? "unknown",
+    ...teamId ? { teamId } : {},
+    text,
+    isMention: false
+  };
+  return {
+    kind: "slash-command",
+    command: readString(payload.command) ?? "unknown",
+    activity,
+    ...triggerId ? { triggerId } : {},
+    ...responseUrl ? { responseUrl } : {},
+    ...userName ? { userName } : {},
+    ...channelName ? { channelName } : {},
+    ...teamDomain ? { teamDomain } : {},
+    ...appId ? { appId } : {},
+    ...enterpriseId ? { enterpriseId } : {},
+    ...enterpriseName ? { enterpriseName } : {},
+    ...payload.is_enterprise_install !== void 0 ? {
+      isEnterpriseInstall: payload.is_enterprise_install === true || payload.is_enterprise_install === "true"
+    } : {}
+  };
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+// src/entrypoints/shortcuts.ts
+function parseSlackShortcutEntrypoint(payload) {
+  return payload.type === "message_action" || payload.message ? parseSlackMessageShortcutEntrypoint(payload) : parseSlackGlobalShortcutEntrypoint(payload);
+}
+function parseSlackGlobalShortcutEntrypoint(payload) {
+  return {
+    kind: "global-shortcut",
+    ...parseShortcutBase(payload)
+  };
+}
+function parseSlackMessageShortcutEntrypoint(payload) {
+  const base = parseShortcutBase(payload);
+  const message = readRecord(payload.message) ?? {};
+  const channel = readRecord(payload.channel);
+  const channelId = readString2(channel?.id) ?? readString2(message.channel) ?? "unknown";
+  const messageTs = readString2(payload.message_ts) ?? readString2(message.ts) ?? void 0;
+  const threadTs = readString2(message.thread_ts);
+  const isThread = Boolean(threadTs && threadTs !== messageTs);
+  const responseUrl = readString2(payload.response_url);
+  const channelName = readString2(channel?.name);
+  const selectedMessageUserId = readString2(message.user);
+  const text = extractSlackMessageText(message, {
+    stripLeadingMentions: channelId.startsWith("D") ? false : true
+  });
+  const activity = {
+    channelId,
+    channelType: resolveSlackChannelType(channelId, threadTs, isThread),
+    userId: base.userId,
+    ...base.teamId ? { teamId: base.teamId } : {},
+    ...isThread ? { threadTs } : {},
+    ...messageTs ? { messageTs } : {},
+    text,
+    isMention: false
+  };
+  return {
+    kind: "message-shortcut",
+    ...base,
+    activity,
+    ...responseUrl ? { responseUrl } : {},
+    selectedMessage: {
+      channelId,
+      ...channelName ? { channelName } : {},
+      ...messageTs ? { messageTs } : {},
+      ...threadTs ? { threadTs } : {},
+      ...selectedMessageUserId ? { userId: selectedMessageUserId } : {},
+      text
+    }
+  };
+}
+function parseShortcutBase(payload) {
+  const user = readRecord(payload.user);
+  const team = readRecord(payload.team);
+  const enterprise = readRecord(payload.enterprise);
+  const teamId = readString2(team?.id) ?? readString2(user?.team_id);
+  const enterpriseId = readString2(enterprise?.id) ?? readString2(team?.enterprise_id);
+  const enterpriseName = readString2(enterprise?.name) ?? readString2(team?.enterprise_name);
+  const triggerId = readString2(payload.trigger_id);
+  const actionTs = readString2(payload.action_ts);
+  const userName = readString2(user?.name) ?? readString2(user?.username);
+  const teamDomain = readString2(team?.domain);
+  return {
+    callbackId: readString2(payload.callback_id) ?? "unknown",
+    userId: readString2(user?.id) ?? "unknown",
+    ...triggerId ? { triggerId } : {},
+    ...actionTs ? { actionTs } : {},
+    ...userName ? { userName } : {},
+    ...teamId ? { teamId } : {},
+    ...teamDomain ? { teamDomain } : {},
+    ...enterpriseId ? { enterpriseId } : {},
+    ...enterpriseName ? { enterpriseName } : {},
+    ...payload.is_enterprise_install !== void 0 ? { isEnterpriseInstall: payload.is_enterprise_install } : {}
+  };
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+export {
+  parseSlackGlobalShortcutEntrypoint,
+  parseSlackMessageShortcutEntrypoint,
+  parseSlackShortcutEntrypoint,
+  parseSlackSlashCommandEntrypoint
+};

package/dist/{history.d.ts → history/index.d.ts}

@@ -1,6 +1,6 @@
-import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
 import { ConversationsHistoryResponse, ConversationsRepliesResponse, WebClient } from '@slack/web-api';
-import { L as Logger } from './logging-Bl3HfcC8.js';
+import { L as Logger } from '../logging-Bl3HfcC8.js';
 
 type SlackContextFragmentRole = "system" | "user";
 type SlackContextFragmentPlacement = "before-history" | "after-latest-user" | "after-history";

package/dist/{history.js → history/index.js}

@@ -1,6 +1,6 @@
 import {
   extractSlackMessageText
-} from "./chunk-FPCE5V5Y.js";
+} from "../chunk-FPCE5V5Y.js";
 
 // src/history/context/assistant-root.ts
 function normalizeAssistantSurfaceThreadRootMessages(messages, options) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { S as SlackActivityInfo, a as SlackChannelType, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
 export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackApprovalRequest, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackEventInteractiveRequestHandler, SlackHumanInputRequest, SlackInteractiveMessage, SlackInteractiveMessageRef, SlackInteractiveRequest, SlackInteractiveRequestBaseContext, SlackInteractiveRequestContext, SlackInteractiveRequestHandler, SlackInteractiveRequestKind, SlackInteractiveResponder, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
-export { PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackSyncMessagePolicyStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages } from './policy.js';
+export { InMemorySlackThreadParticipationStateStoreOptions, PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, PostgresSlackThreadParticipationStateStore, PostgresSlackThreadParticipationStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackQuietThreadRejectedDecision, SlackSyncMessagePolicyStateStore, SlackThreadAwareMessagePolicyConfig, SlackThreadAwareMessagePolicyDecision, SlackThreadAwareMessagePolicyResolver, SlackThreadParticipationEligibility, SlackThreadParticipationEligibilityOptions, SlackThreadParticipationMode, SlackThreadParticipationPostgresClient, SlackThreadParticipationPruneResult, SlackThreadParticipationReactivation, SlackThreadParticipationState, SlackThreadParticipationStateContext, SlackThreadParticipationStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages } from './policy/index.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';

package/dist/index.js

@@ -1,12 +1,30 @@
-import "./chunk-NE57BLLU.js";
+import {
+  createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
+  createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
+  prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
+  shouldRegisterSlackPassiveChannelMessages
+} from "./chunk-DNVSH7H5.js";
 import {
   currentSlackTurnContext,
   formatSlackAttributedFollowUp,
-  markdownToSlackMrkdwn,
-  resolveSlackMessageFormatter,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-JZG4IETE.js";
+} from "./chunk-X4WBBBYM.js";
+import {
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter
+} from "./chunk-6WHFQUYQ.js";
 import {
   extractSlackActionToken,
   extractSlackAuthContext,
@@ -22,21 +40,13 @@ import {
   resolveSlackChannelType,
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
-import {
-  createAsyncSlackMessagePolicyResolver,
-  createInMemorySlackMessagePolicyStateStore,
-  createPostgresSlackMessagePolicyStateStore,
-  createSlackMessagePolicyMessageKey,
-  createSlackMessagePolicyResolver,
-  createSlackMessagePolicyThreadKey,
-  initializePostgresSlackMessagePolicyState,
-  prunePostgresSlackMessagePolicyState,
-  shouldRegisterSlackPassiveChannelMessages
-} from "./chunk-CMR6B76C.js";
 export {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
@@ -49,13 +59,16 @@ export {
   extractSlackUserIdentity,
   formatSlackAttributedFollowUp,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   isProcessableMessage,
   markdownToSlackMrkdwn,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
+  resolveSlackThreadParticipationEligibility,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   shouldRegisterSlackPassiveChannelMessages,

package/dist/{policy.d.ts → policy/index.d.ts}

@@ -1,4 +1,4 @@
-import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
 
 type MaybePromise<T> = T | Promise<T>;
 type SlackChannelMessagePolicy = "disabled" | "mentioned-threads" | "allowed-channels" | "any-added-channel";
@@ -173,4 +173,105 @@ declare function createInMemorySlackMessagePolicyStateStore({ maxAcceptedMessage
     maxMentionedThreads?: number;
 }): SlackSyncMessagePolicyStateStore;
 
-export { type PostgresSlackMessagePolicyPruneResult, type PostgresSlackMessagePolicyStateStore, type PostgresSlackMessagePolicyStateStoreOptions, type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyPostgresClient, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackSyncMessagePolicyStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages };
+type SlackThreadParticipationMode = "quiet" | "active";
+interface SlackThreadParticipationState {
+    mode: "quiet";
+    reason?: string;
+    sourceMessageTs?: string;
+    updatedAt?: string;
+    updatedByUserId?: string;
+}
+interface SlackThreadParticipationStateContext {
+    activity: SlackActivityInfo;
+    key: string;
+}
+interface SlackThreadParticipationPruneResult {
+    quietThreadsDeleted: number;
+}
+interface SlackThreadParticipationStateStore {
+    get(key: string, context: SlackThreadParticipationStateContext): Promise<SlackThreadParticipationState | undefined>;
+    setQuiet(key: string, state: Omit<SlackThreadParticipationState, "mode" | "updatedAt">, context: SlackThreadParticipationStateContext): Promise<void>;
+    clear(key: string, context: SlackThreadParticipationStateContext): Promise<void>;
+    close?(): Promise<void>;
+    prune?(): Promise<SlackThreadParticipationPruneResult>;
+}
+interface SlackThreadParticipationEligibility {
+    available: boolean;
+    reason?: string;
+    threadKey?: string;
+    threadTs?: string;
+}
+interface SlackThreadParticipationEligibilityOptions {
+    activity: SlackActivityInfo;
+    policy: Pick<SlackMessagePolicyConfig, "messagePolicy" | "threadReplyPolicy">;
+    stateStore?: SlackThreadParticipationStateStore;
+}
+interface InMemorySlackThreadParticipationStateStoreOptions {
+    maxThreads?: number;
+    now?: () => Date;
+}
+interface SlackThreadParticipationPostgresClient {
+    end?: () => Promise<void>;
+    query<T = unknown>(sql: string, values?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount?: number | null;
+    }>;
+}
+interface PostgresSlackThreadParticipationStateStoreOptions {
+    client?: SlackThreadParticipationPostgresClient;
+    connectionString?: string;
+    ensureSchema?: boolean;
+    onPruneError?: (error: unknown) => void;
+    pruneBatchSize?: number;
+    pruneIntervalMs?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}
+interface PostgresSlackThreadParticipationStateStore extends SlackThreadParticipationStateStore {
+    close(): Promise<void>;
+    prune(): Promise<SlackThreadParticipationPruneResult>;
+}
+declare function resolveSlackThreadParticipationEligibility({ activity, policy, stateStore, }: SlackThreadParticipationEligibilityOptions): SlackThreadParticipationEligibility;
+declare function createInMemorySlackThreadParticipationStateStore({ maxThreads, now, }?: InMemorySlackThreadParticipationStateStoreOptions): SlackThreadParticipationStateStore;
+declare function createPostgresSlackThreadParticipationStateStore({ client, connectionString, ensureSchema, onPruneError, pruneBatchSize, pruneIntervalMs, retentionMs, schema, tableName, }: PostgresSlackThreadParticipationStateStoreOptions): PostgresSlackThreadParticipationStateStore;
+declare function initializePostgresSlackThreadParticipationState({ client, ensureSchema, schema, tableName, }: {
+    client: SlackThreadParticipationPostgresClient;
+    ensureSchema?: boolean;
+    schema?: string;
+    tableName?: string;
+}): Promise<void>;
+declare function prunePostgresSlackThreadParticipationState({ client, pruneBatchSize, retentionMs, schema, tableName, }: {
+    client: SlackThreadParticipationPostgresClient;
+    pruneBatchSize?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}): Promise<SlackThreadParticipationPruneResult>;
+
+interface SlackThreadParticipationReactivation {
+    reason?: string;
+    threadKey: string;
+    threadTs?: string;
+}
+interface SlackQuietThreadRejectedDecision {
+    accepted: false;
+    activity: SlackActivityInfo;
+    reason: "quiet-thread";
+    threadKey: string;
+    threadParticipationReason?: string;
+    threadTs?: string;
+}
+type SlackThreadAwareMessagePolicyDecision = (SlackMessagePolicyDecision & {
+    reactivatedThreadParticipation?: SlackThreadParticipationReactivation;
+}) | SlackQuietThreadRejectedDecision;
+interface SlackThreadAwareMessagePolicyResolver {
+    resolve(activity: SlackActivityInfo): Promise<SlackThreadAwareMessagePolicyDecision>;
+    resolveMessage(activity: SlackActivityInfo): Promise<string | undefined>;
+}
+interface SlackThreadAwareMessagePolicyConfig extends SlackAsyncMessagePolicyConfig {
+    threadParticipationStore?: SlackThreadParticipationStateStore;
+}
+declare function createAsyncSlackThreadAwareMessagePolicyResolver(config?: SlackThreadAwareMessagePolicyConfig): SlackThreadAwareMessagePolicyResolver;
+
+export { type InMemorySlackThreadParticipationStateStoreOptions, type PostgresSlackMessagePolicyPruneResult, type PostgresSlackMessagePolicyStateStore, type PostgresSlackMessagePolicyStateStoreOptions, type PostgresSlackThreadParticipationStateStore, type PostgresSlackThreadParticipationStateStoreOptions, type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyPostgresClient, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackQuietThreadRejectedDecision, type SlackSyncMessagePolicyStateStore, type SlackThreadAwareMessagePolicyConfig, type SlackThreadAwareMessagePolicyDecision, type SlackThreadAwareMessagePolicyResolver, type SlackThreadParticipationEligibility, type SlackThreadParticipationEligibilityOptions, type SlackThreadParticipationMode, type SlackThreadParticipationPostgresClient, type SlackThreadParticipationPruneResult, type SlackThreadParticipationReactivation, type SlackThreadParticipationState, type SlackThreadParticipationStateContext, type SlackThreadParticipationStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages };

package/dist/{policy.js → policy/index.js}

@@ -1,22 +1,34 @@
 import {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
   shouldRegisterSlackPassiveChannelMessages
-} from "./chunk-CMR6B76C.js";
+} from "../chunk-DNVSH7H5.js";
 export {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
   shouldRegisterSlackPassiveChannelMessages
 };

package/dist/runtime-BNBHOZSQ.d.ts

@@ -0,0 +1,53 @@
+import { Logger } from '@slack/bolt';
+import { L as Logger$1 } from './logging-Bl3HfcC8.js';
+
+type SlackSocketModeRuntimePolicy = "single-instance" | "external-coordination";
+interface SlackSocketModeReceiverRuntimeOptions {
+    autoReconnectEnabled?: boolean;
+    clientPingTimeout?: number;
+    pingPongLoggingEnabled?: boolean;
+    serverPingTimeout?: number;
+}
+interface SlackSocketModeRuntimeOptions {
+    appSlug: string;
+    appToken?: string;
+    autoReconnectEnabled?: boolean;
+    clientPingTimeoutMs?: number;
+    exitProcess?: (code: number) => never | void;
+    lockDir?: string;
+    lockEnabled?: boolean;
+    logger?: Logger$1;
+    logLevel?: "debug" | "info" | "warn" | "error";
+    pingPongLoggingEnabled?: boolean;
+    restartGuardEnabled?: boolean;
+    restartGuardMaxWarnings?: number;
+    restartGuardWindowMs?: number;
+    runtimePolicy?: SlackSocketModeRuntimePolicy;
+    serverPingTimeoutMs?: number;
+}
+interface SlackSocketModeRuntime {
+    boltAppOptions: {
+        logger: Logger;
+    };
+    close(): void;
+    socketModeReceiverOptions: SlackSocketModeReceiverRuntimeOptions;
+}
+interface SlackSocketModeRestartGuard {
+    record(message: string): void;
+}
+declare function createSlackSocketModeRuntime({ appSlug, appToken, autoReconnectEnabled, clientPingTimeoutMs, exitProcess, lockDir, lockEnabled, logger, logLevel, pingPongLoggingEnabled, restartGuardEnabled, restartGuardMaxWarnings, restartGuardWindowMs, runtimePolicy, serverPingTimeoutMs, }: SlackSocketModeRuntimeOptions): SlackSocketModeRuntime;
+declare function createSlackSocketModeRestartGuard({ enabled, exitProcess, logger, maxWarnings, windowMs, }: {
+    enabled: boolean;
+    exitProcess: (code: number) => never | void;
+    logger?: Logger$1;
+    maxWarnings: number;
+    windowMs: number;
+}): SlackSocketModeRestartGuard;
+declare function createSlackSdkLogger({ level, logger, restartGuard, }: {
+    level: "debug" | "info" | "warn" | "error";
+    logger?: Logger$1;
+    restartGuard?: SlackSocketModeRestartGuard;
+}): Logger;
+declare function redactSlackSocketModeLogValue(value: unknown, depth?: number): unknown;
+
+export { type SlackSocketModeReceiverRuntimeOptions as S, type SlackSocketModeRestartGuard as a, type SlackSocketModeRuntime as b, type SlackSocketModeRuntimeOptions as c, type SlackSocketModeRuntimePolicy as d, createSlackSdkLogger as e, createSlackSocketModeRestartGuard as f, createSlackSocketModeRuntime as g, redactSlackSocketModeLogValue as r };