@cuylabs/channel-slack 0.1.0

package/dist/index.d.ts

@@ -0,0 +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 { SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackSyncMessagePolicyStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, shouldRegisterSlackPassiveChannelMessages } from './policy.js';
+export { L as Logger } from './logging-Bl3HfcC8.js';

package/dist/index.js

@@ -0,0 +1,57 @@
+import "./chunk-NE57BLLU.js";
+import {
+  currentSlackTurnContext,
+  formatSlackAttributedFollowUp,
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter,
+  resolveThreadAwareSlackSessionId,
+  runWithSlackTurnContext
+} from "./chunk-JZG4IETE.js";
+import {
+  extractSlackActionToken,
+  extractSlackAuthContext,
+  extractSlackUserIdentity,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity
+} from "./chunk-TWJGVDA2.js";
+import {
+  extractSlackAttachmentsText,
+  extractSlackBlocksText,
+  extractSlackMessageText,
+  isProcessableMessage,
+  resolveSlackChannelType,
+  stripLeadingMentions
+} from "./chunk-FPCE5V5Y.js";
+import {
+  createAsyncSlackMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  shouldRegisterSlackPassiveChannelMessages
+} from "./chunk-BODPT4I6.js";
+export {
+  createAsyncSlackMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  currentSlackTurnContext,
+  extractSlackActionToken,
+  extractSlackAttachmentsText,
+  extractSlackAuthContext,
+  extractSlackBlocksText,
+  extractSlackMessageText,
+  extractSlackUserIdentity,
+  formatSlackAttributedFollowUp,
+  isProcessableMessage,
+  markdownToSlackMrkdwn,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  resolveSlackChannelType,
+  resolveSlackMessageFormatter,
+  resolveThreadAwareSlackSessionId,
+  runWithSlackTurnContext,
+  shouldRegisterSlackPassiveChannelMessages,
+  stripLeadingMentions
+};

package/dist/logging-Bl3HfcC8.d.ts

@@ -0,0 +1,8 @@
+interface Logger {
+    debug?(message: string, attributes?: Record<string, unknown>): void;
+    info?(message: string, attributes?: Record<string, unknown>): void;
+    warn?(message: string, attributes?: Record<string, unknown>): void;
+    error(message: string, attributes?: Record<string, unknown>): void;
+}
+
+export type { Logger as L };

package/dist/policy.d.ts

@@ -0,0 +1,130 @@
+import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+
+type MaybePromise<T> = T | Promise<T>;
+type SlackChannelMessagePolicy = "disabled" | "mentioned-threads" | "allowed-channels" | "any-added-channel";
+type SlackThreadReplyPolicy = "anyone" | "original-user" | "mention-required";
+type SlackMessagePolicyAcceptReason = "direct-message" | "bot-mentioned" | "mentioned-thread-reply" | "allowed-channel" | "any-added-channel";
+type SlackMessagePolicyRejectReason = "duplicate-message-event" | "passive-channel-messages-disabled" | "thread-not-mentioned" | "thread-reply-mention-required" | "thread-reply-not-original-user" | "channel-not-allowed";
+interface SlackMessagePolicyConfig {
+    /**
+     * Channel IDs allowed when `messagePolicy` is `allowed-channels`.
+     */
+    allowedChannelIds?: readonly string[];
+    /**
+     * Passive channel behavior for non-mentioned messages. DMs and direct
+     * mentions are always accepted.
+     *
+     * @default "disabled"
+     */
+    messagePolicy?: SlackChannelMessagePolicy;
+    /**
+     * Continuation policy for non-mentioned replies inside a thread the bot was
+     * mentioned in.
+     *
+     * @default "mention-required"
+     */
+    threadReplyPolicy?: SlackThreadReplyPolicy;
+    /**
+     * Maximum remembered mentioned threads for `mentioned-threads` policy.
+     *
+     * @default 10000
+     */
+    maxMentionedThreads?: number;
+    /**
+     * Maximum accepted message event keys used for duplicate suppression.
+     *
+     * @default 10000
+     */
+    maxAcceptedMessages?: number;
+    /**
+     * Optional synchronous state backing for mentioned-thread tracking and
+     * accepted-message duplicate suppression. Use
+     * `createAsyncSlackMessagePolicyResolver` for async/persistent stores.
+     */
+    stateStore?: SlackSyncMessagePolicyStateStore;
+}
+interface SlackMessagePolicyAcceptedDecision {
+    accepted: true;
+    activity: SlackActivityInfo;
+    reason: SlackMessagePolicyAcceptReason;
+    text: string;
+}
+interface SlackMessagePolicyRejectedDecision {
+    accepted: false;
+    activity: SlackActivityInfo;
+    reason: SlackMessagePolicyRejectReason;
+}
+type SlackMessagePolicyDecision = SlackMessagePolicyAcceptedDecision | SlackMessagePolicyRejectedDecision;
+interface SlackMessagePolicyResolver {
+    resolve(activity: SlackActivityInfo): SlackMessagePolicyDecision;
+    /**
+     * Adapter-friendly resolver that returns accepted text or `undefined`.
+     */
+    resolveMessage(activity: SlackActivityInfo): string | undefined;
+}
+interface SlackAsyncMessagePolicyResolver {
+    resolve(activity: SlackActivityInfo): Promise<SlackMessagePolicyDecision>;
+    /**
+     * Adapter-friendly resolver that returns accepted text or `undefined`.
+     */
+    resolveMessage(activity: SlackActivityInfo): Promise<string | undefined>;
+}
+interface SlackMentionedThreadState {
+    originalUserId?: string;
+}
+interface SlackMessagePolicyStateContext {
+    activity: SlackActivityInfo;
+    key: string;
+}
+interface SlackSyncMessagePolicyStateStore {
+    getMentionedThread(key: string, context: SlackMessagePolicyStateContext): SlackMentionedThreadState | undefined;
+    hasAcceptedMessage(key: string, context: SlackMessagePolicyStateContext): boolean;
+    /**
+     * Atomically record this accepted message key if it has not been seen.
+     * Return `true` when this caller claimed the key, or `false` when the key
+     * was already claimed by another resolver/process. When omitted, the
+     * resolver falls back to `hasAcceptedMessage` + `rememberAcceptedMessage`,
+     * which is compatible but not atomic across workers.
+     */
+    claimAcceptedMessage?(key: string, context: SlackMessagePolicyStateContext): boolean;
+    rememberMentionedThread(key: string, state: SlackMentionedThreadState, context: SlackMessagePolicyStateContext): void;
+    rememberAcceptedMessage(key: string, context: SlackMessagePolicyStateContext): void;
+}
+interface SlackMessagePolicyStateStore {
+    getMentionedThread(key: string, context: SlackMessagePolicyStateContext): MaybePromise<SlackMentionedThreadState | undefined>;
+    hasAcceptedMessage(key: string, context: SlackMessagePolicyStateContext): MaybePromise<boolean>;
+    /**
+     * Atomically record this accepted message key if it has not been seen.
+     * Durable stores should implement this as an insert-if-absent / compare-and-
+     * set operation so duplicate Slack events cannot race across workers. When
+     * omitted, the resolver falls back to `hasAcceptedMessage` +
+     * `rememberAcceptedMessage`, which is compatible but not atomic.
+     */
+    claimAcceptedMessage?(key: string, context: SlackMessagePolicyStateContext): MaybePromise<boolean>;
+    rememberMentionedThread(key: string, state: SlackMentionedThreadState, context: SlackMessagePolicyStateContext): MaybePromise<void>;
+    rememberAcceptedMessage(key: string, context: SlackMessagePolicyStateContext): MaybePromise<void>;
+}
+interface SlackAsyncMessagePolicyConfig extends Omit<SlackMessagePolicyConfig, "stateStore"> {
+    /**
+     * Optional state backing for mentioned-thread tracking and accepted-message
+     * duplicate suppression. Implement this with durable storage to preserve
+     * policy state across process restarts.
+     */
+    stateStore?: SlackMessagePolicyStateStore;
+}
+
+declare function createAsyncSlackMessagePolicyResolver(config?: SlackAsyncMessagePolicyConfig): SlackAsyncMessagePolicyResolver;
+
+declare function createSlackMessagePolicyMessageKey(activity: SlackActivityInfo): string | undefined;
+declare function createSlackMessagePolicyThreadKey(activity: SlackActivityInfo): string;
+
+declare function shouldRegisterSlackPassiveChannelMessages(config?: SlackMessagePolicyConfig): boolean;
+
+declare function createSlackMessagePolicyResolver(config?: SlackMessagePolicyConfig): SlackMessagePolicyResolver;
+
+declare function createInMemorySlackMessagePolicyStateStore({ maxAcceptedMessages, maxMentionedThreads, }?: {
+    maxAcceptedMessages?: number;
+    maxMentionedThreads?: number;
+}): SlackSyncMessagePolicyStateStore;
+
+export { type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackSyncMessagePolicyStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, shouldRegisterSlackPassiveChannelMessages };

package/dist/policy.js

@@ -0,0 +1,16 @@
+import {
+  createAsyncSlackMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  shouldRegisterSlackPassiveChannelMessages
+} from "./chunk-BODPT4I6.js";
+export {
+  createAsyncSlackMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  shouldRegisterSlackPassiveChannelMessages
+};

package/dist/setup.d.ts

@@ -0,0 +1,165 @@
+import { InspectSlackConnectionOptions, SlackDiagnosticsClient, SlackConnectionInspection } from './diagnostics.js';
+
+type SlackSetupFeature = "assistant" | "app-mentions" | "direct-messages" | "channel-messages" | "history" | "interactivity" | "feedback" | "user-profiles" | "user-emails";
+type SlackSetupFeaturePreset = "assistant" | "channel-adapter" | "agent-app";
+type SlackSetupTransport = "http" | "socket";
+interface SlackSetupEnvironmentVariable {
+    name: string;
+    purpose: string;
+}
+interface SlackSetupSettingsRequirements {
+    assistantView: boolean;
+    eventSubscriptions: boolean;
+    interactivity: boolean;
+    socketMode: boolean;
+}
+interface SlackSetupRequirements {
+    features: SlackSetupFeature[];
+    transport: SlackSetupTransport;
+    eventsPath: string;
+    requestUrl?: string;
+    botScopes: string[];
+    optionalBotScopes: string[];
+    appTokenScopes: string[];
+    botEvents: string[];
+    settings: SlackSetupSettingsRequirements;
+    environment: SlackSetupEnvironmentVariable[];
+}
+interface GetSlackSetupRequirementsOptions {
+    /**
+     * Package-level preset to start from.
+     *
+     * - `assistant`: Assistant pane plus default feedback controls
+     * - `channel-adapter`: app mentions plus direct messages
+     * - `agent-app`: unified mount defaults: Assistant pane, mentions, DMs, feedback
+     *
+     * Pass `false` to use only the explicit `features` list.
+     *
+     * @default "agent-app"
+     */
+    preset?: SlackSetupFeaturePreset | false;
+    /**
+     * Extra package features used by the host. When omitted, the selected preset
+     * is used as-is.
+     */
+    features?: readonly SlackSetupFeature[];
+    /**
+     * Inbound transport used by the direct Slack app.
+     *
+     * @default "http"
+     */
+    transport?: SlackSetupTransport;
+    /**
+     * Slack Events API callback path for HTTP mode.
+     *
+     * @default "/slack/events"
+     */
+    eventsPath?: string;
+    /**
+     * Public base URL for HTTP mode. When provided, the returned requirements
+     * and generated manifest include the full Slack request URL.
+     */
+    baseUrl?: string;
+    /** App-owned bot scopes to include in addition to package requirements. */
+    extraBotScopes?: readonly string[];
+    /** App-owned optional bot scopes to verify as warnings. */
+    extraOptionalBotScopes?: readonly string[];
+    /** App-owned bot events to include in addition to package requirements. */
+    extraBotEvents?: readonly string[];
+}
+interface SlackManifestAppHome {
+    home_tab_enabled: boolean;
+    messages_tab_enabled: boolean;
+    messages_tab_read_only_enabled: boolean;
+}
+interface SlackManifestSuggestedPrompt {
+    title: string;
+    message: string;
+}
+interface SlackAppManifest {
+    display_information: {
+        name: string;
+        description?: string;
+        background_color?: string;
+    };
+    features: {
+        app_home?: SlackManifestAppHome;
+        bot_user: {
+            display_name: string;
+            always_online?: boolean;
+        };
+        assistant_view?: {
+            assistant_description?: string;
+            suggested_prompts?: SlackManifestSuggestedPrompt[];
+        };
+    };
+    oauth_config: {
+        scopes: {
+            bot: string[];
+            user?: string[];
+        };
+    };
+    settings: {
+        event_subscriptions?: {
+            request_url?: string;
+            bot_events: string[];
+        };
+        interactivity?: {
+            is_enabled: boolean;
+            request_url?: string;
+        };
+        socket_mode_enabled?: boolean;
+        token_rotation_enabled?: boolean;
+        org_deploy_enabled?: boolean;
+        is_mcp_enabled?: boolean;
+    };
+}
+interface CreateSlackAppManifestOptions extends GetSlackSetupRequirementsOptions {
+    name: string;
+    description?: string;
+    backgroundColor?: string;
+    botDisplayName?: string;
+    alwaysOnline?: boolean;
+    assistantDescription?: string;
+    suggestedPrompts?: readonly SlackManifestSuggestedPrompt[];
+    appHome?: false | Partial<SlackManifestAppHome>;
+    extraUserScopes?: readonly string[];
+    tokenRotationEnabled?: boolean;
+    orgDeployEnabled?: boolean;
+    isMcpEnabled?: boolean;
+}
+type SlackAppManifestComparisonFindingSeverity = "warning" | "error";
+interface SlackAppManifestComparisonFinding {
+    severity: SlackAppManifestComparisonFindingSeverity;
+    code: string;
+    message: string;
+    path?: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+interface SlackAppManifestComparison {
+    ok: boolean;
+    missingBotScopes: string[];
+    missingOptionalBotScopes: string[];
+    missingBotEvents: string[];
+    findings: SlackAppManifestComparisonFinding[];
+}
+
+declare const slackSetupFeaturePresets: Readonly<Record<SlackSetupFeaturePreset, readonly SlackSetupFeature[]>>;
+declare function getSlackSetupRequirements(options?: GetSlackSetupRequirementsOptions): SlackSetupRequirements;
+
+declare function createSlackAppManifest(options: CreateSlackAppManifestOptions): SlackAppManifest;
+declare function compareSlackAppManifest(manifest: unknown, requirements: SlackSetupRequirements): SlackAppManifestComparison;
+
+interface InspectSlackAppSetupOptions extends GetSlackSetupRequirementsOptions, Pick<InspectSlackConnectionOptions, "token" | "requestTimeoutMs" | "inspectScopes" | "scopeMethods"> {
+    /** Inject a preconfigured Slack Web API client, useful for OAuth stores/tests. */
+    client?: SlackDiagnosticsClient;
+}
+interface SlackAppSetupInspection {
+    ok: boolean;
+    requirements: SlackSetupRequirements;
+    connection: SlackConnectionInspection;
+}
+declare function inspectSlackAppSetup(options?: InspectSlackAppSetupOptions): Promise<SlackAppSetupInspection>;
+
+export { type CreateSlackAppManifestOptions, type GetSlackSetupRequirementsOptions, type InspectSlackAppSetupOptions, type SlackAppManifest, type SlackAppManifestComparison, type SlackAppManifestComparisonFinding, type SlackAppManifestComparisonFindingSeverity, type SlackAppSetupInspection, SlackDiagnosticsClient, type SlackManifestAppHome, type SlackManifestSuggestedPrompt, type SlackSetupEnvironmentVariable, type SlackSetupFeature, type SlackSetupFeaturePreset, type SlackSetupRequirements, type SlackSetupSettingsRequirements, type SlackSetupTransport, compareSlackAppManifest, createSlackAppManifest, getSlackSetupRequirements, inspectSlackAppSetup, slackSetupFeaturePresets };